A2A MCP एकीकरण

Git Repo：A2A MCP

यह रिपॉजिटरी दिखाती है कि a2a-python SDK को कैसे सेट अप और उपयोग करें ताकि एक सरल सर्वर और क्लाइंट बनाया जा सके जो a2a प्रोटोकॉल को लागू करे, और एजेंट सर्वर mcp द्वारा लागू किया गया है।

अवलोकन

A2A (Agent2Agent): इंटरऑपरेबल AI एजेंट्स बनाने के लिए एक प्रोटोकॉल और SDK।
यह उदाहरण: दिखाता है कि एक बुनियादी A2A सर्वर और क्लाइंट कैसे चलाएं, संदेशों का आदान-प्रदान करें, और प्रतिक्रिया देखें।

आवश्यकताएं

Python 3.13+
uv (तेज़ निर्भरता प्रबंधन और चलाने के लिए)
OpenRouter के लिए एक API कुंजी (OPENROUTER_API_KEY के रूप में सेट करें)

स्थापना

रिपॉजिटरी को क्लोन करें:

git clone https://github.com/sing1ee/a2a-mcp-openrouter
cd https://github.com/sing1ee/a2a-mcp-openrouter

निर्भरताएं स्थापित करें:
```
uv venv
source .venv/bin/activate
```
पर्यावरण चर सेट करें:
```
export OPENROUTER_API_KEY=your-openrouter-api-key
```
या एक .env फ़ाइल बनाएं:
```
OPENROUTER_API_KEY=your-openrouter-api-key
```
नोट: आप अपनी OpenRouter API कुंजी https://openrouter.ai/ से प्राप्त कर सकते हैं

उदाहरण चलाना

1. सर्वर शुरू करें

uv run --env-file .env a2a-server

सर्वर पोर्ट 9999 पर शुरू होगा।

एजेंट कार्ड को मान्य करें:

2. क्लाइंट चलाएं

एक नए टर्मिनल में:

uv venv
source .venv/bin/activate
uv run --env-file .env a2a-client --question "A2A प्रोटोकॉल क्या है?"

क्लाइंट सर्वर से कनेक्ट होगा और एक अनुरोध भेजेगा।

3. प्रतिक्रिया देखें

क्लाइंट से प्रतिक्रिया response.xml में सहेजी जाएगी।

कॉन्फ़िगरेशन

सिस्टम निम्नलिखित कॉन्फ़िगरेशन का उपयोग करता है:

मॉडल: OpenRouter के माध्यम से google/gemini-flash-1.5
बेस URL: https://openrouter.ai/api/v1

फ़ाइल संरचना

src/a2a_mcp_openrouter/server/: सर्वर कार्यान्वयन।
src/a2a_mcp_openrouter/client/: क्लाइंट कार्यान्वयन।
response.xml: क्लाइंट से उदाहरण प्रतिक्रिया।

समस्या निवारण

गुम निर्भरताएं: सुनिश्चित करें कि आपके पास uv स्थापित है।
API कुंजी त्रुटियां: सुनिश्चित करें कि OPENROUTER_API_KEY सही तरीके से सेट है।
पोर्ट संघर्ष: सुनिश्चित करें कि पोर्ट 9999 मुफ्त है।

A2A बनाम MCP: प्रोटोकॉल समानताएं और एकीकृत दृष्टिकोण

इस कार्यान्वयन के माध्यम से, हमने पाया कि A2A (Agent2Agent) और MCP (Model Context Protocol) उल्लेखनीय आर्किटेक्चरल समानताएं साझा करते हैं। दोनों प्रोटोकॉल खोज, क्षमता आदान-प्रदान और निष्पादन के लिए समान पैटर्न का पालन करते हैं।

एकीकृत कार्यान्वयन पैटर्न

मुख्य खोज: A2A और MCP दोनों समान अंतर्निहित कार्यान्वयन पैटर्न का पालन करते हैं:

HTTP-आधारित संचार: दोनों संचार के लिए HTTP का उपयोग करते हैं (A2A REST APIs का उपयोग करता है, MCP Server-Sent Events का उपयोग करता है)
प्रॉम्प्ट-संचालित डिज़ाइन: दोनों यह तय करने के लिए LLM प्रॉम्प्ट पर निर्भर करते हैं कि क्या कॉल करना है और कैसे कॉल करना है
खोज तंत्र: दोनों उपलब्ध क्षमताओं को खोजने के तरीके प्रदान करते हैं
संरचित प्रतिक्रियाएं: दोनों संरचित डेटा वापस करते हैं जिसे प्रोग्रामेटिक रूप से संसाधित किया जा सकता है

mcp.py कार्यान्वयन को देखते हुए, हम देख सकते हैं:

# HTTP के माध्यम से MCP टूल खोज
async with sse_client(url) as (read, write):
    resources = await session.list_tools()
    
# LLM निर्णय लेने के लिए प्रॉम्प्ट जेनरेट करें
return template.render(tools=resources.tools)

# HTTP के माध्यम से टूल कॉल निष्पादित करें
return await session.call_tool(tool_name, arguments=arguments)

यह A2A एजेंट कॉलिंग पैटर्न के समान है - क्षमताओं की खोज करें, यह तय करने के लिए LLM का उपयोग करें कि क्या कॉल करना है, फिर कॉल निष्पादित करें।

सार्वभौमिक इंटरफेस के रूप में A2A

मुख्य अंतर्दृष्टि: A2A एजेंट-टू-एजेंट संचार और टूल इनवोकेशन दोनों के लिए एक एकीकृत इंटरफेस के रूप में काम कर सकता है, क्योंकि कॉलिंग पैटर्न अनिवार्य रूप से समान हैं:

A2A → एजेंट: क्लाइंट → HTTP → एजेंट → LLM प्रतिक्रिया
A2A → टूल: क्लाइंट → HTTP → टूल रैपर → MCP टूल प्रतिक्रिया

दोनों पैटर्न का उपयोग करते हैं:

HTTP संचार
क्षमता खोज
LLM-संचालित निर्णय लेना
संरचित अनुरोध/प्रतिक्रिया प्रारूप

इस एकीकृत दृष्टिकोण के लाभ

एकल इंटरफेस: क्लाइंट्स को केवल एक कॉलिंग पैटर्न को समझने की आवश्यकता है
इंटरऑपरेबिलिटी: एक ही वर्कफ़्लो में एजेंट्स और टूल्स को निर्बाध रूप से मिलाएं
सुसंगत आर्किटेक्चर: विभिन्न क्षमता प्रकारों में समान कार्यान्वयन पैटर्न
LLM-मूल डिज़ाइन: दोनों बुद्धिमान क्षमता चयन के लिए LLM तर्क का लाभ उठाते हैं

यह दर्शाता है कि A2A और MCP प्रतिस्पर्धी प्रोटोकॉल नहीं हैं बल्कि पूरक पैटर्न हैं जिन्हें एक एकल इंटरफेस प्रतिमान के तहत एकीकृत किया जा सकता है।

सिस्टम आर्किटेक्चर और फ़्लो

नीचे एक विस्तृत अनुक्रम आरेख है जो क्लाइंट इनपुट से अंतिम प्रतिक्रिया तक A2A प्रोटोकॉल के पूर्ण फ़्लो को दिखाता है:

sequenceDiagram
    participant User
    participant Client as A2A Client
    participant LLM_Client as OpenRouter LLM (Client)
    participant Server as A2A Server
    participant AgentExecutor as Agent Executor
    participant Agent as Server Agent
    participant LLM_Server as OpenRouter LLM (Server)
    participant MCP as MCP Tool

    User->>Client: Input question: "A2A प्रोटोकॉल क्या है?"
    
    Note over Client: agent_urls के साथ एजेंट को इनिशियलाइज़ करें
    Client->>Server: GET /agent-card - उपलब्ध एजेंट्स की खोज करें
    Server-->>Client: क्षमताओं के साथ AgentCard वापस करें
    
    Note over Client: एजेंट प्रॉम्प्ट टेम्प्लेट रेंडर करें
    Client->>LLM_Client: प्रश्न और उपलब्ध एजेंट्स के साथ निर्णय प्रॉम्प्ट भेजें
    LLM_Client-->>Client: चयनित एजेंट्स के साथ JSON वापस करें
    
    loop प्रत्येक चयनित एजेंट के लिए
        Client->>Server: POST /send-message-streaming
        
        Server->>AgentExecutor: execute(context, event_queue)
        AgentExecutor->>Agent: stream(query)
        
        Agent->>MCP: उपलब्ध टूल्स प्राप्त करें
        MCP-->>Agent: टूल परिभाषाएं वापस करें
        
        Note over Agent: टूल प्रॉम्प्ट टेम्प्लेट रेंडर करें
        Agent->>LLM_Server: प्रश्न और टूल्स के साथ निर्णय प्रॉम्प्ट भेजें
        LLM_Server-->>Agent: चयनित टूल्स के साथ JSON वापस करें
        
        loop प्रत्येक चयनित टूल के लिए (अधिकतम पुनरावृत्तियां)
            Agent->>MCP: तर्कों के साथ टूल कॉल करें
            MCP-->>Agent: टूल परिणाम वापस करें
            
            Note over Agent: called_tools इतिहास अपडेट करें
            Agent->>LLM_Server: टूल परिणामों के साथ अपडेटेड प्रॉम्प्ट भेजें
            LLM_Server-->>Agent: अगले टूल्स या अंतिम उत्तर वापस करें
            
            alt अधिक टूल्स की आवश्यकता
                Note over Agent: अगली पुनरावृत्ति पर जारी रखें
            else कार्य पूर्ण
                Note over Agent: कार्य पूर्ण
            end
        end
        
        Agent-->>AgentExecutor: स्ट्रीमिंग इवेंट्स यील्ड करें
        AgentExecutor-->>Server: event_queue में इवेंट्स फॉरवर्ड करें
        Server-->>Client: HTTP के माध्यम से प्रतिक्रिया चंक्स स्ट्रीम करें
        
        Client->>Client: प्रतिक्रिया टैग्स से उत्तर निकालें
        Note over Client: agent_answers सूची में जोड़ें
    end
    
    alt अंतिम संश्लेषण की आवश्यकता
        Client->>LLM_Client: सभी उत्तरों के साथ संश्लेषण प्रॉम्प्ट भेजें
        LLM_Client-->>Client: अंतिम संश्लेषित उत्तर वापस करें
    else कोई संश्लेषण की आवश्यकता नहीं
        Note over Client: मौजूदा उत्तरों का उपयोग करें
    end
    
    Client-->>User: एजेंट आउटपुट के साथ अंतिम प्रतिक्रिया स्ट्रीम करें

मुख्य विशेषताएं

एजेंट खोज: A2A प्रोटोकॉल के माध्यम से उपलब्ध एजेंट्स की स्वचालित खोज
LLM-संचालित चयन: LLM तर्क का उपयोग करके बुद्धिमान एजेंट और टूल चयन
MCP एकीकरण: ज्ञान पुनर्प्राप्ति के लिए MCP टूल्स के साथ निर्बाध एकीकरण
स्ट्रीमिंग पाइपलाइन: पूरी पाइपलाइन में रियल-टाइम स्ट्रीमिंग प्रतिक्रियाएं
पुनरावृत्त प्रसंस्करण: बनाए रखे गए संदर्भ के साथ मल्टी-इटरेशन टूल कॉलिंग

फ़्लो विवरण

सिस्टम इन मुख्य चरणों का पालन करता है:

क्लाइंट चरण: उपयोगकर्ता प्रश्न इनपुट करता है → क्लाइंट एजेंट्स की खोज करता है → LLM प्रासंगिक एजेंट्स का चयन करता है

सर्वर चरण: सर्वर अनुरोध प्राप्त करता है → एजेंट टूल्स की खोज करता है → LLM टूल्स का चयन करता है → टूल्स पुनरावृत्त रूप से निष्पादित होते हैं

प्रतिक्रिया चरण: परिणाम पाइपलाइन के माध्यम से वापस स्ट्रीम होते हैं → क्लाइंट अंतिम उत्तर का संश्लेषण करता है → उपयोगकर्ता को प्रतिक्रिया मिलती है

यह आर्किटेक्चर इंटरऑपरेबल AI एजेंट्स बनाने में A2A प्रोटोकॉल की शक्ति को प्रदर्शित करता है जो एक-दूसरे की खोज कर सकते हैं और सहयोग कर सकते हैं, जबकि बाहरी ज्ञान स्रोतों तक पहुंचने के लिए MCP टूल्स का लाभ उठाते हैं।