microsoft--mcp-for-beginners/translations/ml/05-AdvancedTopics/web-search-mcp/README.md

പാഠം: വെബ് സെർച്ച് MCP സെർവർ നിർമ്മാണം

ഈ അധ്യായം എങ്ങനെ യഥാർത്ഥ ലോക AI ഏജന്റ് നിർമ്മിക്കാമെന്ന് കാണിക്കുന്നു, അത് ബാഹ്യ API-കളുമായി സംയോജിപ്പിക്കുകയും, വ്യത്യസ്ത ഡാറ്റാ തരം കൈകാര്യം ചെയ്യുകയും, പിശകുകൾ നിയന്ത്രിക്കുകയും, ഒട്ടനവധി ടൂളുകൾ ഏകോപിപ്പിക്കുകയും ചെയ്യുന്നു—എല്ലാം പ്രൊഡക്ഷൻ-സജ്ജമായ ഫോർമാറ്റിൽ. നിങ്ങൾ കാണും:

• അധികാരപത്രം ആവശ്യമായ ബാഹ്യ API-കളുമായി സംയോജനം
• വിവിധ എൻഡ്‌പോയിന്റുകളിൽ നിന്നുള്ള വ്യത്യസ്ത ഡാറ്റാ തരം കൈകാര്യം ചെയ്യൽ
• ദൃഢമായ പിശക് കൈകാര്യം ചെയ്യലും ലോഗിംഗ് തന്ത്രങ്ങളും
• ഒറ്റ സെർവറിൽ മൾട്ടി-ടൂൾ ഏകോപനം

അവസാനത്തിൽ, നിങ്ങൾക്ക് ആധുനിക AI-യും LLM-ചാലിത ആപ്ലിക്കേഷനുകൾക്കും അനിവാര്യമായ പാറ്റേണുകളും മികച്ച പ്രാക്ടീസുകളും പ്രായോഗികമായി അറിയാം.

പരിചയം

ഈ പാഠത്തിൽ, SerpAPI ഉപയോഗിച്ച് റിയൽ-ടൈം വെബ് ഡാറ്റ ഉപയോഗിച്ച് LLM ശേഷികൾ വിപുലീകരിക്കുന്ന ഒരു ആധുനിക MCP സെർവർ, ക്ലയന്റ് നിർമ്മിക്കുന്ന വിധം നിങ്ങൾക്ക് പഠിക്കാം. വെബിൽ നിന്നുള്ള പുതുക്കിയ വിവരങ്ങൾ ആക്സസ് ചെയ്യാൻ കഴിയുന്ന ഡൈനാമിക് AI ഏജന്റുകൾ വികസിപ്പിക്കുന്നതിന് ഇത് ഒരു നിർണായക കഴിവാണ്.

പഠന ലക്ഷ്യങ്ങൾ

ഈ പാഠം അവസാനിക്കുമ്പോൾ, നിങ്ങൾക്ക് കഴിയും:

• MCP സെർവറിൽ SerpAPI പോലുള്ള ബാഹ്യ API-കൾ സുരക്ഷിതമായി സംയോജിപ്പിക്കുക
• വെബ്, വാർത്ത, ഉൽപ്പന്ന തിരയൽ, Q&A എന്നിവയ്ക്കായി ഒട്ടനവധി ടൂളുകൾ നടപ്പിലാക്കുക
• LLM ഉപയോഗത്തിനായി ഘടനാപരമായ ഡാറ്റ പാഴ്സ് ചെയ്ത് ഫോർമാറ്റ് ചെയ്യുക
• പിശകുകൾ കൈകാര്യം ചെയ്യുകയും API നിരക്ക് പരിധികൾ ഫലപ്രദമായി നിയന്ത്രിക്കുകയും ചെയ്യുക
• സ്വയം പ്രവർത്തിക്കുന്നതും ഇന്ററാക്ടീവ് മോഡിലുമായ MCP ക്ലയന്റുകൾ നിർമ്മിച്ച് പരീക്ഷിക്കുക

വെബ് സെർച്ച് MCP സെർവർ

ഈ വിഭാഗം വെബ് സെർച്ച് MCP സെർവറിന്റെ ആർക്കിടെക്ചറും സവിശേഷതകളും പരിചയപ്പെടുത്തുന്നു. FastMCPയും SerpAPIയും ചേർന്ന് LLM ശേഷികൾ റിയൽ-ടൈം വെബ് ഡാറ്റ ഉപയോഗിച്ച് എങ്ങനെ വിപുലീകരിക്കാമെന്ന് കാണാം.

അവലോകനം

ഈ നടപ്പാക്കൽ MCP-യുടെ വിവിധ, ബാഹ്യ API-ചാലിത ടാസ്കുകൾ സുരക്ഷിതവും ഫലപ്രദവുമായ രീതിയിൽ കൈകാര്യം ചെയ്യാനുള്ള കഴിവ് പ്രദർശിപ്പിക്കുന്ന നാല് ടൂളുകൾ ഉൾക്കൊള്ളുന്നു:

• general_search: വ്യാപകമായ വെബ് ഫലങ്ങൾക്കായി
• news_search: പുതിയ തലക്കെട്ടുകൾക്കായി
• product_search: ഇ-കൊമേഴ്‌സ് ഡാറ്റക്കായി
• qna: ചോദ്യോത്തര സ്നിപ്പറ്റുകൾക്കായി

സവിശേഷതകൾ

• കോഡ് ഉദാഹരണങ്ങൾ: പൈത്തൺ (മറ്റു ഭാഷകളിലേക്ക് എളുപ്പത്തിൽ വിപുലീകരിക്കാവുന്നതും) ഉപയോഗിച്ച് ഭാഷാ-നിർദിഷ്ട കോഡ് ബ്ലോക്കുകൾ ഉൾക്കൊള്ളുന്നു, വ്യക്തതയ്ക്കായി കോഡ് പിവറ്റുകൾ ഉപയോഗിച്ച്

Python

# general_search ഉപകരണത്തിന്റെ ഉദാഹരണ ഉപയോഗം
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

async def run_search():
    server_params = StdioServerParameters(
        command="python",
        args=["server.py"],
    )
    async with stdio_client(server_params) as (reader, writer):
        async with ClientSession(reader, writer) as session:
            await session.initialize()
            result = await session.call_tool("general_search", arguments={"query": "open source LLMs"})
            print(result)

---

ക്ലയന്റ് പ്രവർത്തിപ്പിക്കുന്നതിന് മുമ്പ്, സെർവർ എന്ത് ചെയ്യുന്നു എന്ന് മനസ്സിലാക്കുന്നത് സഹായകരമാണ്. server.py ഫയൽ MCP സെർവർ നടപ്പിലാക്കുന്നു, SerpAPI-യുമായി സംയോജിപ്പിച്ച് വെബ്, വാർത്ത, ഉൽപ്പന്ന തിരയൽ, Q&A ടൂളുകൾ പ്രദർശിപ്പിക്കുന്നു. ഇത് വരവേൽക്കുന്ന അഭ്യർത്ഥനകൾ കൈകാര്യം ചെയ്യുകയും API കോൾസ് നിയന്ത്രിക്കുകയും, പ്രതികരണങ്ങൾ പാഴ്സ് ചെയ്ത് ഘടനാപരമായ ഫലങ്ങൾ ക്ലയന്റിന് തിരികെ നൽകുകയും ചെയ്യുന്നു.

പൂർണ്ണ നടപ്പാക്കൽ നിങ്ങൾക്ക് server.py ൽ പരിശോധിക്കാം.

സെർവർ ഒരു ടൂൾ എങ്ങനെ നിർവചിച്ച് രജിസ്റ്റർ ചെയ്യുന്നു എന്നതിന് ഒരു ലഘു ഉദാഹരണം:

Python Server

# server.py (ഉദ്ധരണം)
from mcp.server import MCPServer, Tool

async def general_search(query: str):
    # ...നിർവഹണം...

server = MCPServer()
server.add_tool(Tool("general_search", general_search))

if __name__ == "__main__":
    server.run()

---

• ബാഹ്യ API സംയോജനം: API കീകൾക്കും ബാഹ്യ അഭ്യർത്ഥനകൾക്കും സുരക്ഷിതമായ കൈകാര്യം കാണിക്കുന്നു
• ഘടനാപരമായ ഡാറ്റ പാഴ്സിംഗ്: API പ്രതികരണങ്ങളെ LLM-സൗഹൃദ ഫോർമാറ്റുകളായി മാറ്റുന്നത് കാണിക്കുന്നു
• പിശക് കൈകാര്യം ചെയ്യൽ: അനുയോജ്യമായ ലോഗിംഗോടുകൂടിയ ദൃഢമായ പിശക് കൈകാര്യം
• ഇന്ററാക്ടീവ് ക്ലയന്റ്: സ്വയം പ്രവർത്തിക്കുന്ന ടെസ്റ്റുകളും ഇന്ററാക്ടീവ് മോഡും ഉൾക്കൊള്ളുന്നു
• സന്ദർഭം മാനേജ്മെന്റ്: MCP Context ഉപയോഗിച്ച് ലോഗിംഗ്, അഭ്യർത്ഥനകൾ ട്രാക്ക് ചെയ്യൽ

മുൻകൂട്ടി ആവശ്യങ്ങൾ

തുടങ്ങുന്നതിന് മുമ്പ്, നിങ്ങളുടെ പരിസ്ഥിതി ശരിയായി സജ്ജമാക്കിയിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുക. ഇതിന് താഴെ പറയുന്ന ഘട്ടങ്ങൾ പിന്തുടരുക. ഇത് എല്ലാ ആശ്രിതങ്ങളും ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ടെന്നും API കീകൾ ശരിയായി ക്രമീകരിച്ചിട്ടുണ്ടെന്നും ഉറപ്പാക്കും.

• Python 3.8 അല്ലെങ്കിൽ അതിനുമുകളിൽ
• SerpAPI API കീ (SerpAPI ൽ സൈൻ അപ്പ് ചെയ്യുക - സൗജന്യ ടിയർ ലഭ്യമാണ്)

ഇൻസ്റ്റലേഷൻ

തുടങ്ങാൻ, നിങ്ങളുടെ പരിസ്ഥിതി സജ്ജമാക്കാൻ താഴെ പറയുന്ന ഘട്ടങ്ങൾ പിന്തുടരുക:

1. uv (ശുപാർശ ചെയ്യുന്നു) അല്ലെങ്കിൽ pip ഉപയോഗിച്ച് ആശ്രിതങ്ങൾ ഇൻസ്റ്റാൾ ചെയ്യുക:

# uv ഉപയോഗിക്കുന്നു (ശുപാർശ ചെയ്യുന്നു)
uv pip install -r requirements.txt

# പിപ്പ് ഉപയോഗിക്കുന്നു
pip install -r requirements.txt

2. പ്രോജക്ട് റൂട്ടിൽ .env ഫയൽ സൃഷ്ടിച്ച് നിങ്ങളുടെ SerpAPI കീ ചേർക്കുക:

SERPAPI_KEY=your_serpapi_key_here

ഉപയോഗം

വെബ് സെർച്ച് MCP സെർവർ SerpAPI-യുമായി സംയോജിപ്പിച്ച് വെബ്, വാർത്ത, ഉൽപ്പന്ന തിരയൽ, Q&A ടൂളുകൾ പ്രദർശിപ്പിക്കുന്ന പ്രധാന ഘടകമാണ്. ഇത് വരവേൽക്കുന്ന അഭ്യർത്ഥനകൾ കൈകാര്യം ചെയ്യുകയും API കോൾസ് നിയന്ത്രിക്കുകയും, പ്രതികരണങ്ങൾ പാഴ്സ് ചെയ്ത് ഘടനാപരമായ ഫലങ്ങൾ ക്ലയന്റിന് തിരികെ നൽകുകയും ചെയ്യുന്നു.

പൂർണ്ണ നടപ്പാക്കൽ നിങ്ങൾക്ക് server.py ൽ പരിശോധിക്കാം.

സെർവർ പ്രവർത്തിപ്പിക്കൽ

MCP സെർവർ ആരംഭിക്കാൻ താഴെ കാണുന്ന കമാൻഡ് ഉപയോഗിക്കുക:

python server.py

സെർവർ stdio-അടിസ്ഥാനമാക്കിയ MCP സെർവറായി പ്രവർത്തിക്കും, ക്ലയന്റ് നേരിട്ട് കണക്ട് ചെയ്യാൻ കഴിയും.

ക്ലയന്റ് മോഡുകൾ

ക്ലയന്റ് (client.py) MCP സെർവറുമായി ഇടപഴകാൻ രണ്ട് മോഡുകൾ പിന്തുണയ്ക്കുന്നു:

• സാധാരണ മോഡ്: എല്ലാ ടൂളുകളും പരീക്ഷിക്കുന്ന സ്വയം പ്രവർത്തിക്കുന്ന ടെസ്റ്റുകൾ നടത്തുന്നു. സെർവർ, ടൂളുകൾ ശരിയായി പ്രവർത്തിക്കുന്നുണ്ടോ എന്ന് വേഗത്തിൽ പരിശോധിക്കാൻ ഇത് ഉപകാരപ്രദമാണ്.
• ഇന്ററാക്ടീവ് മോഡ്: മെനു-നിർദ്ദേശിത ഇന്റർഫേസ് ആരംഭിച്ച്, നിങ്ങൾക്ക് ടൂളുകൾ കൈമാറി വിളിക്കാനും, ഇഷ്ടാനുസൃത ക്വെറിയുകൾ നൽകാനും, ഫലങ്ങൾ റിയൽ ടൈമിൽ കാണാനും കഴിയും. സെർവറിന്റെ ശേഷികൾ അന്വേഷിക്കാൻ, വ്യത്യസ്ത ഇൻപുട്ടുകൾ പരീക്ഷിക്കാൻ ഇത് അനുയോജ്യമാണ്.

പൂർണ്ണ നടപ്പാക്കൽ നിങ്ങൾക്ക് client.py ൽ പരിശോധിക്കാം.

ക്ലയന്റ് പ്രവർത്തിപ്പിക്കൽ

സ്വയം പ്രവർത്തിക്കുന്ന ടെസ്റ്റുകൾ നടത്താൻ (ഇത് സ്വയം സെർവർ ആരംഭിക്കും):

python client.py

അല്ലെങ്കിൽ ഇന്ററാക്ടീവ് മോഡിൽ പ്രവർത്തിപ്പിക്കാൻ:

python client.py --interactive

വ്യത്യസ്ത രീതികളിൽ പരീക്ഷണം

സെർവർ നൽകുന്ന ടൂളുകൾ പരീക്ഷിക്കാനും ഇടപഴകാനും നിരവധി മാർഗ്ഗങ്ങളുണ്ട്, നിങ്ങളുടെ ആവശ്യങ്ങൾക്കും പ്രവൃത്തി രീതിക്കും അനുസരിച്ച്.

MCP Python SDK ഉപയോഗിച്ച് ഇഷ്ടാനുസൃത ടെസ്റ്റ് സ്ക്രിപ്റ്റുകൾ എഴുതൽ

നിങ്ങൾക്ക് MCP Python SDK ഉപയോഗിച്ച് നിങ്ങളുടെ സ്വന്തം ടെസ്റ്റ് സ്ക്രിപ്റ്റുകൾ നിർമ്മിക്കാം:

Python

from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

async def test_custom_query():
    server_params = StdioServerParameters(
        command="python",
        args=["server.py"],
    )
    
    async with stdio_client(server_params) as (reader, writer):
        async with ClientSession(reader, writer) as session:
            await session.initialize()
            # നിങ്ങളുടെ ഇഷ്ടാനുസൃത പാരാമീറ്ററുകളുമായി ടൂളുകൾ വിളിക്കുക
            result = await session.call_tool("general_search", 
                                           arguments={"query": "your custom query"})
            # ഫലം പ്രോസസ്സ് ചെയ്യുക

---

ഈ സാഹചര്യത്തിൽ, "ടെസ്റ്റ് സ്ക്രിപ്റ്റ്" എന്നത് MCP സെർവറിന്റെ ക്ലയന്റായി പ്രവർത്തിക്കുന്ന ഇഷ്ടാനുസൃത പൈത്തൺ പ്രോഗ്രാമിനെ സൂചിപ്പിക്കുന്നു. ഔപചാരിക യൂണിറ്റ് ടെസ്റ്റ് അല്ലാതെ, ഈ സ്ക്രിപ്റ്റ് പ്രോഗ്രാമാറ്റിക്കായി സെർവറുമായി കണക്ട് ചെയ്ത്, നിങ്ങൾ തിരഞ്ഞെടുക്കുന്ന പാരാമീറ്ററുകളോടെ ടൂളുകൾ വിളിച്ച് ഫലങ്ങൾ പരിശോധിക്കാൻ സഹായിക്കുന്നു. ഈ സമീപനം ഉപകാരപ്രദമാണ്:

• ടൂൾ കോൾസ് പ്രോട്ടോടൈപ്പ് ചെയ്യാനും പരീക്ഷിക്കാനും
• സെർവർ വ്യത്യസ്ത ഇൻപുട്ടുകൾക്ക് എങ്ങനെ പ്രതികരിക്കുന്നു എന്ന് സ്ഥിരീകരിക്കാനും
• ആവർത്തിക്കുന്ന ടൂൾ വിളിപ്പുകൾ ഓട്ടോമേറ്റുചെയ്യാനും
• MCP സെർവറിന്റെ മുകളിൽ നിങ്ങളുടെ സ്വന്തം പ്രവൃത്തി പ്രവാഹങ്ങൾ അല്ലെങ്കിൽ സംയോജനങ്ങൾ നിർമ്മിക്കാനും

നിങ്ങൾക്ക് പുതിയ ക്വെറിയുകൾ വേഗത്തിൽ പരീക്ഷിക്കാനും, ടൂൾ പെരുമാറ്റം ഡീബഗ് ചെയ്യാനും, കൂടുതൽ ആധുനിക ഓട്ടോമേഷൻ ആരംഭിക്കാനും ടെസ്റ്റ് സ്ക്രിപ്റ്റുകൾ ഉപയോഗിക്കാം. താഴെ MCP Python SDK ഉപയോഗിച്ച് ഇത്തരമൊരു സ്ക്രിപ്റ്റ് സൃഷ്ടിക്കുന്ന ഉദാഹരണം കാണിക്കുന്നു:

ടൂൾ വിവരണങ്ങൾ

സെർവർ നൽകുന്ന വിവിധ തരത്തിലുള്ള തിരയലുകൾക്കും ക്വെറിയുകൾക്കും താഴെ പറയുന്ന ടൂളുകൾ ഉപയോഗിക്കാം. ഓരോ ടൂളിന്റെയും പാരാമീറ്ററുകളും ഉദാഹരണ ഉപയോഗവും താഴെ വിശദീകരിച്ചിരിക്കുന്നു.

ഈ വിഭാഗം ലഭ്യമായ ഓരോ ടൂളിന്റെയും വിശദാംശങ്ങളും അവയുടെ പാരാമീറ്ററുകളും നൽകുന്നു.

general_search

വ്യാപകമായ വെബ് തിരയൽ നടത്തുകയും ഫോർമാറ്റ് ചെയ്ത ഫലങ്ങൾ തിരികെ നൽകുകയും ചെയ്യുന്നു.

ഈ ടൂൾ എങ്ങനെ വിളിക്കാം:

MCP Python SDK ഉപയോഗിച്ച് നിങ്ങളുടെ സ്വന്തം സ്ക്രിപ്റ്റിൽ നിന്നും അല്ലെങ്കിൽ ഇൻസ്പെക്ടർ അല്ലെങ്കിൽ ഇന്ററാക്ടീവ് ക്ലയന്റ് മോഡ് ഉപയോഗിച്ച് ഇന്ററാക്ടീവായി general_search വിളിക്കാം. SDK ഉപയോഗിച്ചുള്ള കോഡ് ഉദാഹരണം:

Python Example

from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

async def run_general_search():
    server_params = StdioServerParameters(
        command="python",
        args=["server.py"],
    )
    async with stdio_client(server_params) as (reader, writer):
        async with ClientSession(reader, writer) as session:
            await session.initialize()
            result = await session.call_tool("general_search", arguments={"query": "latest AI trends"})
            print(result)

---

അല്ലെങ്കിൽ, ഇന്ററാക്ടീവ് മോഡിൽ, മെനുവിൽ നിന്ന് general_search തിരഞ്ഞെടുക്കുകയും പ്രോംപ്റ്റ് വന്നപ്പോൾ നിങ്ങളുടെ ക്വെറി നൽകുകയും ചെയ്യുക.

പാരാമീറ്ററുകൾ:

• query (സ്ട്രിംഗ്): തിരയൽ ക്വെറി

ഉദാഹരണ അഭ്യർത്ഥന:

{
  "query": "latest AI trends"
}

news_search

ഒരു ക്വെറിയുമായി ബന്ധപ്പെട്ട പുതിയ വാർത്താ ലേഖനങ്ങൾ തിരയുന്നു.

ഈ ടൂൾ എങ്ങനെ വിളിക്കാം:

MCP Python SDK ഉപയോഗിച്ച് നിങ്ങളുടെ സ്വന്തം സ്ക്രിപ്റ്റിൽ നിന്നും അല്ലെങ്കിൽ ഇൻസ്പെക്ടർ അല്ലെങ്കിൽ ഇന്ററാക്ടീവ് ക്ലയന്റ് മോഡ് ഉപയോഗിച്ച് ഇന്ററാക്ടീവായി news_search വിളിക്കാം. SDK ഉപയോഗിച്ചുള്ള കോഡ് ഉദാഹരണം:

Python Example

from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

async def run_news_search():
    server_params = StdioServerParameters(
        command="python",
        args=["server.py"],
    )
    async with stdio_client(server_params) as (reader, writer):
        async with ClientSession(reader, writer) as session:
            await session.initialize()
            result = await session.call_tool("news_search", arguments={"query": "AI policy updates"})
            print(result)

---

അല്ലെങ്കിൽ, ഇന്ററാക്ടീവ് മോഡിൽ, മെനുവിൽ നിന്ന് news_search തിരഞ്ഞെടുക്കുകയും പ്രോംപ്റ്റ് വന്നപ്പോൾ നിങ്ങളുടെ ക്വെറി നൽകുകയും ചെയ്യുക.

പാരാമീറ്ററുകൾ:

• query (സ്ട്രിംഗ്): തിരയൽ ക്വെറി

ഉദാഹരണ അഭ്യർത്ഥന:

{
  "query": "AI policy updates"
}

product_search

ഒരു ക്വെറിയുമായി പൊരുത്തപ്പെടുന്ന ഉൽപ്പന്നങ്ങൾ തിരയുന്നു.

ഈ ടൂൾ എങ്ങനെ വിളിക്കാം:

MCP Python SDK ഉപയോഗിച്ച് നിങ്ങളുടെ സ്വന്തം സ്ക്രിപ്റ്റിൽ നിന്നും അല്ലെങ്കിൽ ഇൻസ്പെക്ടർ അല്ലെങ്കിൽ ഇന്ററാക്ടീവ് ക്ലയന്റ് മോഡ് ഉപയോഗിച്ച് ഇന്ററാക്ടീവായി product_search വിളിക്കാം. SDK ഉപയോഗിച്ചുള്ള കോഡ് ഉദാഹരണം:

Python Example

from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

async def run_product_search():
    server_params = StdioServerParameters(
        command="python",
        args=["server.py"],
    )
    async with stdio_client(server_params) as (reader, writer):
        async with ClientSession(reader, writer) as session:
            await session.initialize()
            result = await session.call_tool("product_search", arguments={"query": "best AI gadgets 2025"})
            print(result)

---

അല്ലെങ്കിൽ, ഇന്ററാക്ടീവ് മോഡിൽ, മെനുവിൽ നിന്ന് product_search തിരഞ്ഞെടുക്കുകയും പ്രോംപ്റ്റ് വന്നപ്പോൾ നിങ്ങളുടെ ക്വെറി നൽകുകയും ചെയ്യുക.

പാരാമീറ്ററുകൾ:

• query (സ്ട്രിംഗ്): ഉൽപ്പന്ന തിരയൽ ക്വെറി

ഉദാഹരണ അഭ്യർത്ഥന:

{
  "query": "best AI gadgets 2025"
}

qna

തിരയൽ എഞ്ചിനുകളിൽ നിന്നുള്ള ചോദ്യങ്ങൾക്ക് നേരിട്ടുള്ള ഉത്തരങ്ങൾ ലഭ്യമാക്കുന്നു.

ഈ ടൂൾ എങ്ങനെ വിളിക്കാം:

MCP Python SDK ഉപയോഗിച്ച് നിങ്ങളുടെ സ്വന്തം സ്ക്രിപ്റ്റിൽ നിന്നും അല്ലെങ്കിൽ ഇൻസ്പെക്ടർ അല്ലെങ്കിൽ ഇന്ററാക്ടീവ് ക്ലയന്റ് മോഡ് ഉപയോഗിച്ച് ഇന്ററാക്ടീവായി qna വിളിക്കാം. SDK ഉപയോഗിച്ചുള്ള കോഡ് ഉദാഹരണം:

Python Example

from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

async def run_qna():
    server_params = StdioServerParameters(
        command="python",
        args=["server.py"],
    )
    async with stdio_client(server_params) as (reader, writer):
        async with ClientSession(reader, writer) as session:
            await session.initialize()
            result = await session.call_tool("qna", arguments={"question": "what is artificial intelligence"})
            print(result)

---

അല്ലെങ്കിൽ, ഇന്ററാക്ടീവ് മോഡിൽ, മെനുവിൽ നിന്ന് qna തിരഞ്ഞെടുക്കുകയും പ്രോംപ്റ്റ് വന്നപ്പോൾ നിങ്ങളുടെ ചോദ്യമൊരുക്കുകയും ചെയ്യുക.

പാരാമീറ്ററുകൾ:

• question (സ്ട്രിംഗ്): ഉത്തരം കണ്ടെത്തേണ്ട ചോദ്യമ്

ഉദാഹരണ അഭ്യർത്ഥന:

{
  "question": "what is artificial intelligence"
}

കോഡ് വിശദാംശങ്ങൾ

ഈ വിഭാഗം സെർവർ, ക്ലയന്റ് നടപ്പാക്കലുകൾക്കുള്ള കോഡ് സ്നിപ്പറ്റുകളും റഫറൻസുകളും നൽകുന്നു.

Python

പൂർണ്ണ നടപ്പാക്കൽ വിശദാംശങ്ങൾക്കായി server.pyയും client.pyയും കാണുക.

# server.py-ൽ നിന്നുള്ള ഉദാഹരണ സ്നിപ്പറ്റ്:
import os
import httpx
# ...നിലവിലുള്ള കോഡ്...

---

ഈ പാഠത്തിലെ ആധുനിക ആശയങ്ങൾ

നിർമ്മാണം ആരംഭിക്കുന്നതിന് മുമ്പ്, ഈ അധ്യായത്തിൽ തുടർച്ചയായി പ്രത്യക്ഷപ്പെടുന്ന ചില പ്രധാന ആധുനിക ആശയങ്ങൾ ഇവിടെ കൊടുക്കുന്നു. ഇവ മനസ്സിലാക്കുന്നത് നിങ്ങളെ സഹായിക്കും, നിങ്ങൾക്ക് പുതിയവയാണെങ്കിലും:

• മൾട്ടി-ടൂൾ ഏകോപനം: വെബ് സെർച്ച്, വാർത്താ സെർച്ച്, ഉൽപ്പന്ന സെർച്ച്, Q&A പോലുള്ള വിവിധ ടൂളുകൾ ഒറ്റ MCP സെർവറിൽ പ്രവർത്തിപ്പിക്കുന്നത്. ഇത് നിങ്ങളുടെ സെർവർ ഒരേ സമയം വിവിധ ടാസ്കുകൾ കൈകാര്യം ചെയ്യാൻ സഹായിക്കുന്നു.
• API നിരക്ക് പരിധി കൈകാര്യം ചെയ്യൽ: SerpAPI പോലുള്ള പല ബാഹ്യ API-കളും ഒരു നിശ്ചിത സമയത്ത് എത്ര അഭ്യർത്ഥനകൾ നടത്താമെന്ന് പരിധി നിശ്ചയിക്കുന്നു. നല്ല കോഡ് ഈ പരിധികൾ പരിശോധിച്ച്, പരിധി തികഞ്ഞാൽ സുഖപ്രദമായി കൈകാര്യം ചെയ്യുന്നു, അതിനാൽ ആപ്പ് തകരാറിലാകാറില്ല.
• ഘടനാപരമായ ഡാറ്റ പാഴ്സിംഗ്: API പ്രതികരണങ്ങൾ പലപ്പോഴും സങ്കീർണ്ണവും നസ്റ്റ് ചെയ്തതും ആണ്. ഈ ആശയം ആ പ്രതികരണങ്ങളെ LLM-കൾക്കും മറ്റ് പ്രോഗ്രാമുകൾക്കും സൗഹൃദമായ, ശുദ്ധവും എളുപ്പത്തിൽ ഉപയോഗിക്കാവുന്നതുമായ ഫോർമാറ്റുകളായി മാറ്റുന്നതിനെ കുറിച്ചാണ്.
• പിശക് പുനരുദ്ധാരണം: ചിലപ്പോൾ പ്രശ്നങ്ങൾ ഉണ്ടാകാം—നെറ്റ്‌വർക്ക് തകരാറിലാകാം, API പ്രതീക്ഷിച്ചതുപോലെ മറുപടി നൽകാതിരിക്കാം. പിശക് പുനരുദ്ധാരണം എന്നത് ഈ പ്രശ്നങ്ങൾ കൈകാര്യം ചെയ്ത്, ക്രാഷ് ചെയ്യാതെ ഉപകാരപ്രദമായ ഫീഡ്ബാക്ക് നൽകാൻ നിങ്ങളുടെ കോഡ് കഴിവുള്ളതായിരിക്കണം.
• പാരാമീറ്റർ പരിശോധന: നിങ്ങളുടെ ടൂളുകൾക്ക് നൽകുന്ന എല്ലാ ഇൻപുട്ടുകളും ശരിയാണെന്നും സുരക്ഷിതമാണെന്നും പരിശോധിക്കുന്നതും ഉൾക്കൊള്ളുന്നു. ഡീഫോൾട്ട് മൂല്യങ്ങൾ സജ്ജമാക്കുകയും ടൈപ്പുകൾ ശരിയാണെന്ന് ഉറപ്പാക്കുകയും ചെയ്യുന്നു, ഇത് ബഗുകളും ആശയക്കുഴപ്പങ്ങളും തടയാൻ സഹായിക്കുന്നു.

പ്രശ്നപരിഹാരം

വെബ് സെർച്ച് MCP സെർവറുമായി പ്രവർത്തിക്കുമ്പോൾ, ചിലപ്പോൾ പ്രശ്നങ്ങൾ നേരിടാം—ബാഹ്യ API-കളുമായി പുതിയ ടൂളുകൾ വികസിപ്പിക്കുമ്പോൾ ഇത് സാധാരണമാണ്. ഈ വിഭാഗം ഏറ്റവും സാധാരണ പ്രശ്നങ്ങൾക്ക് പ്രായോഗിക പരിഹാരങ്ങൾ നൽകുന്നു, അതിനാൽ നിങ്ങൾ വേഗത്തിൽ പുനഃസ്ഥാപിക്കാം. പിശക് നേരിടുമ്പോൾ, ആദ്യം ഇവിടെ തുടങ്ങുക: താഴെ കൊടുത്തിരിക്കുന്ന ടിപ്പുകൾ പലപ്പോഴും അധിക സഹായം തേടാതെ പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നു.

സാധാരണ പ്രശ്നങ്ങൾ

ഉപയോക്താക്കൾ നേരിടുന്ന ഏറ്റവും സാധാരണ പ്രശ്നങ്ങളും അവയുടെ വിശദീകരണങ്ങളും പരിഹാര നടപടികളും താഴെ കൊടുത്തിരിക്കുന്നു:

1. .env ഫയലിൽ SERPAPI_KEY കാണാനില്ല
   • SERPAPI_KEY environment variable not found എന്ന പിശക് കാണുമ്പോൾ, നിങ്ങളുടെ ആപ്ലിക്കേഷൻ SerpAPI ആക്സസ് ചെയ്യാൻ ആവശ്യമായ API കീ കണ്ടെത്താൻ കഴിയുന്നില്ല. ഇത് പരിഹരിക്കാൻ, നിങ്ങളുടെ പ്രോജക്ട് റൂട്ടിൽ .env എന്ന ഫയൽ സൃഷ്ടിച്ച് SERPAPI_KEY=your_serpapi_key_here എന്ന വരി ചേർക്കുക. ഇവിടെ your_serpapi_key_here DEBUG മോഡ് സജ്ജമാക്കാൻ, നിങ്ങളുടെ client.pyഅല്ലെങ്കിൽserver.py` ഫയലിന്റെ മുകളിൽ ലോഗിംഗ് ലെവൽ DEBUG ആയി സജ്ജമാക്കുക:

Python

# നിങ്ങളുടെ client.py അല്ലെങ്കിൽ server.py ഫയലിന്റെ മുകളിൽ
import logging
logging.basicConfig(
    level=logging.DEBUG,  # INFO-യിൽ നിന്ന് DEBUG-യിലേക്ക് മാറ്റുക
    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
)

---

---

അടുത്തത് എന്താണ്

• 5.10 റിയൽ ടൈം സ്ട്രീമിംഗ്

---

അസൂയാ:
ഈ രേഖ AI വിവർത്തന സേവനം Co-op Translator ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖ അധികാരപരമായ ഉറവിടമായി കണക്കാക്കണം. നിർണായക വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.