डेवलपर नॉलेज एमसीपी सर्वर को कस्टम एआई एजेंट के साथ इंटिग्रेट करना

इस ट्यूटोरियल में बताया गया है कि LangChain, LlamaIndex, और AutoGen की मदद से बनाए गए कस्टम एआई एजेंट फ़्रेमवर्क को रिमोट डेवलपर नॉलेज एमसीपी सर्वर से कैसे कनेक्ट किया जाए.

अपने कस्टम एआई एजेंट को रिमोट मॉडल कॉन्टेक्स्ट प्रोटोकॉल (एमसीपी) सर्वर से कनेक्ट करके, आपके एजेंट Google डेवलपर के आधिकारिक और अप-टू-डेट दस्तावेज़ों को डाइनैमिक तरीके से खोज सकते हैं और उन्हें वापस पा सकते हैं. इन दस्तावेज़ों में Google Cloud, Firebase, Android, Google Maps Platform, Chrome वगैरह के बारे में जानकारी होती है.

ज़रूरी शर्तें

शुरू करने से पहले, इन ज़रूरी शर्तों को पूरा करें:

  1. Developer Knowledge API का पासकोड जनरेट करें: Developer Knowledge API को चालू करें और एपीआई पासकोड सेटअप करने से जुड़ी गाइड में दिए गए निर्देशों का पालन करके, अपने Google Cloud प्रोजेक्ट में एपीआई पासकोड बनाएं.
  2. Gemini API पासकोड जनरेट करें: Gemini मॉडल की पुष्टि करने के लिए, Google AI Studio में एपीआई पासकोड बनाएं. इसके अलावा, अगर आपके Google Cloud API पासकोड पर Generative Language API चालू है, तो उसका फिर से इस्तेमाल करें.

  3. अपने एनवायरमेंट वैरिएबल सेट करें: अपने टर्मिनल में, एपीआई पासकोड को एनवायरमेंट वैरिएबल के तौर पर सेट करें:

    export DEVELOPERKNOWLEDGE_API_KEY="YOUR_API_KEY"
export GEMINI_API_KEY="YOUR_GEMINI_API_KEY"

  4. Python इंस्टॉल करें: पुष्टि करें कि आपके डेवलपमेंट एनवायरमेंट में Python 3.10 या इसके बाद का वर्शन इस्तेमाल किया जा रहा हो.

LangChain का इस्तेमाल करके कनेक्ट करना

LangChain ऐप्लिकेशन, langchain-mcp-adapters पैकेज या स्टैंडर्ड एमसीपी क्लाइंट ट्रांसपोर्ट का इस्तेमाल करके, रिमोट एचटीटीपी एमसीपी सर्वर से कनेक्ट हो सकते हैं.

डिपेंडेंसी इंस्टॉल करना

LangChain, Gemini, और MCP के लिए ज़रूरी Python पैकेज इंस्टॉल करें:

pip install langgraph langchain-google-genai langchain-mcp-adapters mcp

LangChain एजेंट को कॉन्फ़िगर करना

यहां दिए गए उदाहरण में, Developer Knowledge MCP सर्वर को Gemini की मदद से काम करने वाले LangChain ReAct एजेंट से कनेक्ट किया गया है. यह स्क्रिप्ट, streamable_http ट्रांसपोर्ट का इस्तेमाल करके MultiServerMCPClient को इंस्टैंशिएट करती है. साथ ही, X-Goog-Api-Key एचटीटीपी हेडर अटैच करती है और रिमोट टूल को create_react_agent में लोड करती है:

import asyncio
import os

from langchain_google_genai import ChatGoogleGenerativeAI
from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent

async def run_langchain_agent():
    api_key = os.environ.get("DEVELOPERKNOWLEDGE_API_KEY")
    if not api_key:
        raise ValueError(
            "DEVELOPERKNOWLEDGE_API_KEY environment variable is required."
        )

    gemini_api_key = os.environ.get("GEMINI_API_KEY")
    if not gemini_api_key:
        raise ValueError("GEMINI_API_KEY environment variable is required.")

    # Configure remote MCP connection for Developer Knowledge
    client = MultiServerMCPClient(
        {
            "google-developer-knowledge": {
                "url": "https://developerknowledge.googleapis.com/mcp",
                "transport": "streamable_http",
                "headers": {
                    "X-Goog-Api-Key": api_key,
                },
            }
        }
    )
    tools = await client.get_tools()

    # Initialize Gemini model and ReAct agent
    llm = ChatGoogleGenerativeAI(
        model="gemini-2.5-flash",
        temperature=0,
        google_api_key=gemini_api_key,
    )
    agent = create_react_agent(llm, tools)

    # Run agent query
    response = await agent.ainvoke(
        {
            "messages": [
                (
                    "user",
                    "How do I list Google Cloud Storage buckets in Python?",
                )
            ]
        }
    )
    print("\nAgent Response:\n", response["messages"][-1].content)

if __name__ == "__main__":
    asyncio.run(run_langchain_agent())

LlamaIndex का इस्तेमाल करके कनेक्ट करना

LlamaIndex, टूल स्पेसिफ़िकेशन के ज़रिए एमसीपी सर्वर के इंटिग्रेशन के साथ काम करता है. इससे रिट्रीवल एजेंट, अनुमान लगाने के दौरान Developer Knowledge के दस्तावेज़ों से क्वेरी कर पाते हैं.

डिपेंडेंसी इंस्टॉल करना

LlamaIndex के मुख्य पैकेज, Gemini LLM, और एमसीपी टूल इंटिग्रेशन को इंस्टॉल करें:

pip install llama-index llama-index-tools-mcp llama-index-llms-google-genai

LlamaIndex एजेंट को कॉन्फ़िगर करना

यहाँ दिए गए उदाहरण में, BasicMCPClient का इस्तेमाल करके रिमोट एमसीपी सर्वर से कनेक्ट किया गया है. इसके बाद, इसे McpToolSpec के साथ रैप किया गया है. साथ ही, वापस लाए गए टूल को Gemini की मदद से काम करने वाले LlamaIndex FunctionAgent से बाइंड किया गया है:

import asyncio
import os

from llama_index.core.agent.workflow import FunctionAgent
from llama_index.llms.google_genai import GoogleGenAI
from llama_index.tools.mcp import BasicMCPClient, McpToolSpec

async def run_llamaindex_agent():
    api_key = os.environ.get("DEVELOPERKNOWLEDGE_API_KEY")
    if not api_key:
        raise ValueError(
            "DEVELOPERKNOWLEDGE_API_KEY environment variable is required."
        )

    gemini_api_key = os.environ.get("GEMINI_API_KEY")
    if not gemini_api_key:
        raise ValueError("GEMINI_API_KEY environment variable is required.")

    # Connect to the remote Developer Knowledge MCP endpoint
    mcp_client = BasicMCPClient(
        "https://developerknowledge.googleapis.com/mcp",
        headers={"X-Goog-Api-Key": api_key},
    )
    mcp_tool_spec = McpToolSpec(client=mcp_client)
    tools = await mcp_tool_spec.to_tool_list_async()

    # Create LlamaIndex FunctionAgent with Gemini
    llm = GoogleGenAI(model="gemini-2.5-flash", api_key=gemini_api_key)
    agent = FunctionAgent(tools=tools, llm=llm)

    # Query the agent
    response = await agent.run(
        "What are the default limits and quotas for the Developer Knowledge"
        " API?"
    )
    print("\nAgent Response:\n", str(response))

if __name__ == "__main__":
    asyncio.run(run_llamaindex_agent())

AutoGen का इस्तेमाल करके कनेक्ट करना

Microsoft AutoGen एजेंट, autogen-ext एमसीपी एक्सटेंशन का इस्तेमाल करके, रिमोट एमसीपी सर्वर से इंटरफ़ेस कर सकते हैं. इससे, एक से ज़्यादा एजेंट के साथ मिलकर काम किया जा सकता है. साथ ही, Google के डेवलपर से जुड़े आधिकारिक दस्तावेज़ों को ऐक्सेस किया जा सकता है.

डिपेंडेंसी इंस्टॉल करना

AutoGen के मुख्य और MCP एक्सटेंशन पैकेज इंस्टॉल करें:

pip install autogen-agentchat "autogen-ext[mcp,openai]"

AutoGen एजेंट को कॉन्फ़िगर करना

यहाँ दिए गए उदाहरण में, StreamableHttpServerParams का इस्तेमाल करके रिमोट एमसीपी सर्वर से कनेक्ट किया गया है. साथ ही, Gemini की मदद से काम करने वाले AutoGen AssistantAgent के साथ डेवलपर नॉलेज टूल रजिस्टर किए गए हैं:

import asyncio
import os

from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.teams import RoundRobinGroupChat
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_ext.tools.mcp import StreamableHttpServerParams, mcp_server_tools

async def run_autogen_agent():
    api_key = os.environ.get("DEVELOPERKNOWLEDGE_API_KEY")
    if not api_key:
        raise ValueError(
            "DEVELOPERKNOWLEDGE_API_KEY environment variable is required."
        )

    gemini_api_key = os.environ.get("GEMINI_API_KEY")
    if not gemini_api_key:
        raise ValueError("GEMINI_API_KEY environment variable is required.")

    # Retrieve remote MCP tools for Developer Knowledge by using Streamable HTTP
    server_params = StreamableHttpServerParams(
        url="https://developerknowledge.googleapis.com/mcp",
        headers={"X-Goog-Api-Key": api_key},
    )
    dk_tools = await mcp_server_tools(server_params)

    # Initialize model client with Gemini and assistant agent
    model_client = OpenAIChatCompletionClient(
        model="gemini-2.5-flash",
        api_key=gemini_api_key,
        base_url="https://generativelanguage.googleapis.com/v1beta/openai/",
    )
    developer_assistant = AssistantAgent(
        name="google_docs_assistant",
        model_client=model_client,
        tools=dk_tools,
        system_message=(
            "You are a developer assistant specializing in Google APIs and"
            " SDKs. Use Developer Knowledge tools to retrieve verified"
            " documentation."
        ),
    )

    # Run query with team runner
    team = RoundRobinGroupChat([developer_assistant], max_turns=5)
    stream = team.run_stream(
        task=(
            "Explain how to configure Firebase Cloud Messaging topic"
            " subscriptions."
        )
    )

    async for message in stream:
        print(message)

if __name__ == "__main__":
    asyncio.run(run_autogen_agent())

एजेंट इंटिग्रेशन के लिए सबसे सही तरीके

डेवलपर नॉलेज एमसीपी सर्वर की मदद से, अपनी पसंद के एआई एजेंट बनाते समय इन दिशा-निर्देशों का पालन करें:

  • सर्च क्वेरी को बेहतर बनाएं: सामान्य शब्दों के बजाय, नैचुरल लैंग्वेज क्वेरी में प्रॉडक्ट के खास नाम और काम के कीवर्ड शामिल करें. ऐसा इसलिए, क्योंकि search_documents और answer_query टूल, क्वेरी के सिमैंटिक से मेल खाते हैं.
  • कॉन्टेक्स्ट विंडो टोकन मैनेज करें: दस्तावेज़ के कॉर्पस से सीधे जवाब पाने के लिए, answer_query का इस्तेमाल करें. साथ ही, get_documents का इस्तेमाल करके पूरे पेज के कॉन्टेंट का अनुरोध न करें. ऐसा तब तक न करें, जब तक search_documents से मिली स्निपेट की जानकारी काफ़ी न हो.
  • एपीआई पासकोड सुरक्षित रखें: अपने Developer Knowledge API और Gemini API पासकोड को एनवायरमेंट वैरिएबल या Secret Manager में सेव करें. साथ ही, क्रेडेंशियल को कभी भी कोड में हार्डकोड न करें.

आगे क्या करना है

डेवलपर नॉलेज एमसीपी सर्वर के बारे में ज़्यादा जानने के लिए, यहां दिए गए संसाधन देखें: