A2A Protocol

A2A JS SDK पूर्ण गाइड: क्विक स्टार्ट गाइड

English中文русскийportuguês한국어日本語हिंदीfrançaisdeutsch
MILO•
Share
A2A JS SDK पूर्ण गाइड: क्विक स्टार्ट गाइड

विषय सूची

  1. A2A JS SDK क्या है?
  2. A2A JS इंस्टॉलेशन और सेटअप
  3. A2A JS मूल अवधारणाएँ
  4. पहला A2A JS एजेंट बनाना
  5. A2A JS सर्वर डेवलपमेंट
  6. A2A JS क्लाइंट का उपयोग
  7. A2A JS उन्नत सुविधाएँ
  8. A2A JS बेस्ट प्रैक्टिस
  9. A2A JS समस्या निवारण

A2A JS SDK क्या है?

A2A JS SDK एक शक्तिशाली लाइब्रेरी है जो Agent2Agent (A2A) प्रोटोकॉल का अनुपालन करने वाले इंटेलिजेंट एजेंट एप्लिकेशन बनाने के लिए JavaScript/TypeScript डेवलपर्स के लिए विशेष रूप से डिज़ाइन की गई है। इस A2A JS फ्रेमवर्क के माध्यम से, डेवलपर्स आसानी से ऐसे इंटेलिजेंट एजेंट सिस्टम बना सकते हैं जो एक-दूसरे के साथ संवाद और सहयोग कर सकते हैं।

A2A JS के मुख्य लाभ

  • 🚀 उपयोग में आसान: A2A JS डेवलपर्स को तेज़ी से शुरू करने के लिए एक सहज API प्रदान करता है
  • 🔄 रीयल-टाइम कम्युनिकेशन: स्ट्रीमिंग प्रोसेसिंग और Server-Sent Events (SSE) सपोर्ट
  • 🛡️ टाइप सेफ्टी: TypeScript आधारित, पूर्ण टाइप सपोर्ट प्रदान करता है
  • 🌐 क्रॉस-प्लेटफॉर्म: A2A JS Node.js और ब्राउज़र दोनों वातावरणों में चल सकता है
  • 📡 मानक प्रोटोकॉल: A2A प्रोटोकॉल स्पेसिफिकेशन का पूर्ण कार्यान्वयन

A2A JS इंस्टॉलेशन और सेटअप

A2A JS SDK इंस्टॉलेशन

npm का उपयोग करके A2A JS SDK इंस्टॉल करें:

npm install @a2a-js/sdk

या yarn का उपयोग करें:

yarn add @a2a-js/sdk

A2A JS इंस्टॉलेशन सत्यापन

A2A JS के सही तरीके से इंस्टॉल होने की पुष्टि के लिए एक सरल टेस्ट फ़ाइल बनाएँ:

import { A2AClient, AgentCard } from "@a2a-js/sdk";

console.log("A2A JS SDK सफलतापूर्वक इंस्टॉल हो गया है!");

A2A JS मूल अवधारणाएँ

A2A JS का उपयोग शुरू करने से पहले, निम्नलिखित मूल अवधारणाओं को समझना महत्वपूर्ण है:

1. एजेंट कार्ड

A2A JS के प्रत्येक एजेंट को एक एजेंट कार्ड की आवश्यकता होती है जो एजेंट की क्षमताओं और इंटरफेस का वर्णन करता है:

import { AgentCard } from "@a2a-js/sdk";

const agentCard: AgentCard = {
  name: 'मेरा A2A JS एजेंट',
  description: 'A2A JS SDK से निर्मित इंटेलिजेंट एजेंट',
  url: 'http://localhost:3000/',
  provider: {
    organization: 'A2A JS डेवलपर',
    url: 'https://example.com'
  },
  version: '1.0.0',
  capabilities: {
    streaming: true,
    pushNotifications: false,
    stateTransitionHistory: true,
  },
  skills: [{
    id: 'general_chat',
    name: 'सामान्य चैट',
    description: 'A2A JS का उपयोग करके सामान्य बातचीत',
    tags: ['chat', 'a2a-js'],
    examples: ['नमस्ते', 'प्रश्नों का उत्तर देने में मदद करें']
  }]
};

2. एजेंट एक्जीक्यूटर

A2A JS का मुख्य निष्पादन तर्क AgentExecutor के माध्यम से कार्यान्वित किया जाता है:

import { AgentExecutor, RequestContext, IExecutionEventBus } from "@a2a-js/sdk";

class MyA2AJSExecutor implements AgentExecutor {
  async execute(
    requestContext: RequestContext,
    eventBus: IExecutionEventBus
  ): Promise<void> {
    // A2A JS एजेंट लॉजिक
    console.log("A2A JS एजेंट अनुरोध प्रसंस्करण कर रहा है...");
  }

  async cancelTask(taskId: string, eventBus: IExecutionEventBus): Promise<void> {
    console.log(`A2A JS टास्क रद्द कर रहा है: ${taskId}`);
  }
}

पहला A2A JS एजेंट बनाना

A2A JS SDK का उपयोग करके एक पूर्ण एजेंट उदाहरण बनाते हैं:

चरण 1: A2A JS एजेंट कार्ड परिभाषित करना

import { AgentCard } from "@a2a-js/sdk";

const myAgentCard: AgentCard = {
  name: 'Hello World A2A JS एजेंट',
  description: 'A2A JS SDK सीखने के लिए मेरा पहला A2A JS एजेंट',
  url: 'http://localhost:3000/',
  provider: {
    organization: 'A2A JS ट्यूटोरियल',
    url: 'https://example.com'
  },
  version: '1.0.0',
  capabilities: {
    streaming: true,
    pushNotifications: false,
    stateTransitionHistory: true,
  },
  defaultInputModes: ['text/plain'],
  defaultOutputModes: ['text/plain'],
  skills: [{
    id: 'hello_world',
    name: 'Hello World',
    description: 'A2A JS उदाहरण स्किल: अभिवादन का जवाब देना',
    tags: ['hello', 'greeting', 'a2a-js'],
    examples: [
      'नमस्ते',
      'स्वागत है',
      'A2A JS के बारे में बताएं'
    ],
    inputModes: ['text/plain'],
    outputModes: ['text/plain']
  }],
  supportsAuthenticatedExtendedCard: false,
};

चरण 2: A2A JS एक्जीक्यूटर कार्यान्वयन

import {
  AgentExecutor,
  RequestContext,
  IExecutionEventBus,
  Task,
  TaskState,
  TaskStatusUpdateEvent
} from "@a2a-js/sdk";
import { v4 as uuidv4 } from "uuid";

class HelloWorldA2AJSExecutor implements AgentExecutor {
  private cancelledTasks = new Set<string>();

  async cancelTask(taskId: string, eventBus: IExecutionEventBus): Promise<void> {
    this.cancelledTasks.add(taskId);
    console.log(`A2A JS एक्जीक्यूटर टास्क रद्द कर रहा है: ${taskId}`);
  }

  async execute(
    requestContext: RequestContext,
    eventBus: IExecutionEventBus
  ): Promise<void> {
    const userMessage = requestContext.userMessage;
    const existingTask = requestContext.task;
    
    const taskId = existingTask?.id || uuidv4();
    const contextId = userMessage.contextId || existingTask?.contextId || uuidv4();

    console.log(`A2A JS एजेंट संदेश प्रसंस्करण कर रहा है: ${userMessage.parts[0]?.text}`);

    // नया टास्क बनाना
    if (!existingTask) {
      const initialTask: Task = {
        kind: 'task',
        id: taskId,
        contextId: contextId,
        status: {
          state: TaskState.Submitted,
          timestamp: new Date().toISOString(),
        },
        history: [userMessage],
        metadata: userMessage.metadata,
        artifacts: [],
      };
      eventBus.publish(initialTask);
    }

    // टास्क स्टेटस प्रकाशित करना
    const workingUpdate: TaskStatusUpdateEvent = {
      kind: 'status-update',
      taskId: taskId,
      contextId: contextId,
      status: {
        state: TaskState.Working,
        message: {
          kind: 'message',
          role: 'agent',
          messageId: uuidv4(),
          parts: [{ kind: 'text', text: 'A2A JS एजेंट सोच रहा है...' }],
          taskId: taskId,
          contextId: contextId,
        },
        timestamp: new Date().toISOString(),
      },
      final: false,
    };
    eventBus.publish(workingUpdate);

    // प्रसंस्करण समय सिमुलेशन
    await new Promise(resolve => setTimeout(resolve, 1000));

    // रद्द स्थिति की जाँच
    if (this.cancelledTasks.has(taskId)) {
      const cancelledUpdate: TaskStatusUpdateEvent = {
        kind: 'status-update',
        taskId: taskId,
        contextId: contextId,
        status: {
          state: TaskState.Canceled,
          timestamp: new Date().toISOString(),
        },
        final: true,
      };
      eventBus.publish(cancelledUpdate);
      return;
    }

    // प्रतिक्रिया उत्पन्न करना
    const userText = userMessage.parts[0]?.text || '';
    let responseText = '';
    
    if (userText.toLowerCase().includes('hello') || userText.toLowerCase().includes('hi')) {
      responseText = `नमस्ते! A2A JS SDK में आपका स्वागत है! मैं A2A JS से निर्मित एक इंटेलिजेंट एजेंट हूँ।`;
    } else if (userText.toLowerCase().includes('a2a js')) {
      responseText = `A2A JS SDK इंटेलिजेंट एजेंट एप्लिकेशन बनाने के लिए एक शक्तिशाली JavaScript लाइब्रेरी है!`;
    } else {
      responseText = `मैं एक A2A JS एजेंट हूँ और मैंने आपका संदेश प्राप्त किया है: "${userText}"। A2A JS SDK का उपयोग करने के लिए धन्यवाद!`;
    }

    // अंतिम परिणाम प्रकाशित करना
    const finalUpdate: TaskStatusUpdateEvent = {
      kind: 'status-update',
      taskId: taskId,
      contextId: contextId,
      status: {
        state: TaskState.Completed,
        message: {
          kind: 'message',
          role: 'agent',
          messageId: uuidv4(),
          parts: [{ kind: 'text', text: responseText }],
          taskId: taskId,
          contextId: contextId,
        },
        timestamp: new Date().toISOString(),
      },
      final: true,
    };
    eventBus.publish(finalUpdate);
  }
}

चरण 3: A2A JS सर्वर शुरू करना

import express from 'express';
import {
  A2AExpressApp,
  DefaultRequestHandler,
  InMemoryTaskStore
} from "@a2a-js/sdk";

const taskStore = new InMemoryTaskStore();
const agentExecutor = new HelloWorldA2AJSExecutor();

const requestHandler = new DefaultRequestHandler(
  myAgentCard,
  taskStore,
  agentExecutor
);

const appBuilder = new A2AExpressApp(requestHandler);
const expressApp = appBuilder.setupRoutes(express(), '');

const PORT = process.env.PORT || 3000;
expressApp.listen(PORT, () => {
  console.log(`A2A JS एजेंट सर्वर http://localhost:${PORT} पर शुरू हो गया है`);
  console.log(`A2A JS एजेंट कार्ड: http://localhost:${PORT}/.well-known/agent.json`);
  console.log('A2A JS सर्वर को रोकने के लिए Ctrl+C दबाएं');
});

A2A JS सर्वर डेवलपमेंट

टास्क स्टोर

A2A JS एक इन-मेमोरी टास्क स्टोर प्रदान करता है और कस्टम स्टोर भी कार्यान्वित किया जा सकता है:

import { TaskStore, Task } from "@a2a-js/sdk";

class CustomA2AJSTaskStore implements TaskStore {
  private tasks = new Map<string, Task>();

  async getTask(taskId: string): Promise<Task | undefined> {
    console.log(`A2A JS टास्क प्राप्त कर रहा है: ${taskId}`);
    return this.tasks.get(taskId);
  }

  async setTask(task: Task): Promise<void> {
    console.log(`A2A JS टास्क सहेज रहा है: ${task.id}`);
    this.tasks.set(task.id, task);
  }

  async deleteTask(taskId: string): Promise<void> {
    console.log(`A2A JS टास्क हटा रहा है: ${taskId}`);
    this.tasks.delete(taskId);
  }
}

मिडलवेयर सपोर्ट

A2A JS Express.js आधारित है और सभी मानक मिडलवेयर का समर्थन करता है:

import cors from 'cors';
import express from 'express';

const app = express();

// A2A JS सर्वर मिडलवेयर कॉन्फ़िगरेशन
app.use(cors());
app.use(express.json());

// कस्टम A2A JS लॉगिंग मिडलवेयर
app.use((req, res, next) => {
  console.log(`A2A JS अनुरोध: ${req.method} ${req.path}`);
  next();
});

A2A JS क्लाइंट का उपयोग

बेसिक क्लाइंट ऑपरेशन्स

import { A2AClient, MessageSendParams } from "@a2a-js/sdk";
import { v4 as uuidv4 } from "uuid";

const client = new A2AClient("http://localhost:3000");

async function testA2AJSClient() {
  console.log("A2A JS क्लाइंट का परीक्षण कर रहा है...");
  
  const messageParams: MessageSendParams = {
    message: {
      messageId: uuidv4(),
      role: "user",
      parts: [{ kind: "text", text: "नमस्ते, A2A JS!" }],
      kind: "message"
    },
    configuration: {
      blocking: true,
      acceptedOutputModes: ['text/plain']
    }
  };

  try {
    const response = await client.sendMessage(messageParams);
    
    if (response.error) {
      console.error("A2A JS क्लाइंट त्रुटि:", response.error);
      return;
    }

    console.log("A2A JS प्रतिक्रिया:", response.result);
  } catch (error) {
    console.error("A2A JS संचार त्रुटि:", error);
  }
}

testA2AJSClient();

A2A JS स्ट्रीमिंग

A2A JS रीयल-टाइम स्ट्रीमिंग कम्युनिकेशन का समर्थन करता है:

import { A2AClient, TaskStatusUpdateEvent } from "@a2a-js/sdk";

async function streamA2AJSResponse() {
  const client = new A2AClient("http://localhost:3000");
  
  console.log("A2A JS स्ट्रीमिंग शुरू कर रहा है...");
  
  const streamParams = {
    message: {
      messageId: uuidv4(),
      role: "user",
      parts: [{ kind: "text", text: "A2A JS का उपयोग करके स्ट्रीमिंग बातचीत" }],
      kind: "message"
    }
  };

  try {
    const stream = client.sendMessageStream(streamParams);
    
    for await (const event of stream) {
      if (event.kind === 'task') {
        console.log(`A2A JS टास्क बनाया गया: ${event.id}`);
      } else if (event.kind === 'status-update') {
        const statusEvent = event as TaskStatusUpdateEvent;
        console.log(`A2A JS स्टेटस अपडेट: ${statusEvent.status.state}`);
        
        if (statusEvent.status.message?.parts[0]?.text) {
          console.log(`A2A JS संदेश: ${statusEvent.status.message.parts[0].text}`);
        }
        
        if (statusEvent.final) {
          console.log("A2A JS स्ट्रीमिंग पूर्ण हुई");
          break;
        }
      }
    }
  } catch (error) {
    console.error("A2A JS स्ट्रीमिंग त्रुटि:", error);
  }
}

A2A JS उन्नत सुविधाएँ

आर्टिफैक्ट प्रोसेसिंग

A2A JS आर्टिफैक्ट जनरेशन और मैनेजमेंट का समर्थन करता है:

import { TaskArtifactUpdateEvent } from "@a2a-js/sdk";

// AgentExecutor से आर्टिफैक्ट प्रकाशित करना
const artifactUpdate: TaskArtifactUpdateEvent = {
  kind: 'artifact-update',
  taskId: taskId,
  contextId: contextId,
  artifact: {
    artifactId: "a2a-js-example",
    name: "A2A JS उदाहरण फ़ाइल",
    parts: [{ 
      text: `# A2A JS द्वारा उत्पन्न सामग्री\n\nयह A2A JS SDK का उपयोग करके उत्पन्न एक उदाहरण फ़ाइल है।`
    }],
  },
  append: false,
  lastChunk: true,
};
eventBus.publish(artifactUpdate);

सुरक्षा कॉन्फ़िगरेशन

A2A JS एजेंट के लिए सुरक्षा विकल्प कॉन्फ़िगर करना:

const secureAgentCard: AgentCard = {
  name: 'सुरक्षित A2A JS एजेंट',
  description: 'सुरक्षित A2A JS एजेंट',
  // ... अन्य कॉन्फ़िगरेशन
  securitySchemes: {
    apiKey: {
      type: 'apiKey',
      name: 'X-API-Key',
      in: 'header'
    }
  },
  security: [{
    apiKey: []
  }]
};

A2A JS बेस्ट प्रैक्टिस

1. त्रुटि हैंडलिंग

A2A JS एप्लिकेशन में व्यापक त्रुटि हैंडलिंग कार्यान्वित करना:

class RobustA2AJSExecutor implements AgentExecutor {
  async execute(requestContext: RequestContext, eventBus: IExecutionEventBus) {
    try {
      // A2A JS निष्पादन लॉजिक
      await this.processRequest(requestContext, eventBus);
    } catch (error) {
      console.error("A2A JS निष्पादन त्रुटि:", error);
      
      // त्रुटि स्थिति प्रकाशित करना
      const errorUpdate: TaskStatusUpdateEvent = {
        kind: 'status-update',
        taskId: requestContext.task?.id || uuidv4(),
        contextId: requestContext.userMessage.contextId || uuidv4(),
        status: {
          state: TaskState.Failed,
          message: {
            kind: 'message',
            role: 'agent',
            messageId: uuidv4(),
            parts: [{ kind: 'text', text: 'A2A JS प्रसंस्करण के दौरान एक त्रुटि हुई। कृपया बाद में पुनः प्रयास करें।' }],
          },
          timestamp: new Date().toISOString(),
        },
        final: true,
      };
      eventBus.publish(errorUpdate);
    }
  }
}

2. प्रदर्शन अनुकूलन

A2A JS एप्लिकेशन का प्रदर्शन अनुकूलित करना:

// कनेक्शन पूलिंग के साथ A2A JS क्लाइंट अनुकूलन
const client = new A2AClient("http://localhost:3000", {
  keepAlive: true,
  timeout: 30000
});

// A2A JS एजेंट प्रतिक्रिया कैशिंग
class CachedA2AJSExecutor implements AgentExecutor {
  private cache = new Map<string, string>();
  
  async execute(requestContext: RequestContext, eventBus: IExecutionEventBus) {
    const userText = requestContext.userMessage.parts[0]?.text || '';
    const cacheKey = `a2a-js-${userText}`;
    
    // A2A JS कैश की जाँच
    if (this.cache.has(cacheKey)) {
      console.log("A2A JS कैश की गई प्रतिक्रिया का उपयोग कर रहा है");
      // कैश की गई प्रतिक्रिया वापस करना
    }
    
    // नया अनुरोध प्रसंस्करण और परिणाम कैशिंग
  }
}

3. लॉगिंग

A2A JS एप्लिकेशन में विस्तृत लॉगिंग जोड़ना:

import { createLogger, format, transports } from 'winston';

const a2aJSLogger = createLogger({
  level: 'info',
  format: format.combine(
    format.timestamp(),
    format.printf(({ timestamp, level, message }) => {
      return `[A2A JS] ${timestamp} ${level}: ${message}`;
    })
  ),
  transports: [
    new transports.Console(),
    new transports.File({ filename: 'a2a-js.log' })
  ]
});

// A2A JS कोड में उपयोग
a2aJSLogger.info('A2A JS एजेंट सफलतापूर्वक शुरू हो गया है');
a2aJSLogger.error('A2A JS प्रसंस्करण त्रुटि', { error: errorDetails });

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

सामान्य समस्याओं का समाधान

1. A2A JS कनेक्शन समस्याएँ

// A2A JS सर्वर कनेक्शन की जाँच
async function checkA2AJSConnection() {
  try {
    const client = new A2AClient("http://localhost:3000");
    const response = await fetch("http://localhost:3000/.well-known/agent.json");
    
    if (response.ok) {
      console.log("A2A JS सर्वर कनेक्शन सामान्य");
    } else {
      console.error("A2A JS सर्वर प्रतिक्रिया असामान्य:", response.status);
    }
  } catch (error) {
    console.error("A2A JS कनेक्शन विफल:", error);
  }
}

निम्नलिखित विधियों को भी आज़माएँ:

2. A2A JS टाइप त्रुटियाँ

A2A JS टाइप्स को सही तरीके से इम्पोर्ट करना सुनिश्चित करें:

// सही A2A JS टाइप्स इम्पोर्ट करना
import {
  AgentCard,
  AgentExecutor,
  A2AClient,
  Task,
  TaskState,
  Message,
  MessageSendParams
} from "@a2a-js/sdk";

3. A2A JS प्रदर्शन डीबगिंग

// A2A JS प्रदर्शन मॉनिटरिंग
class PerformanceA2AJSExecutor implements AgentExecutor {
  async execute(requestContext: RequestContext, eventBus: IExecutionEventBus) {
    const startTime = Date.now();
    console.log(`A2A JS प्रसंस्करण शुरू: ${startTime}`);
    
    try {
      // A2A JS लॉजिक
      await this.processRequest(requestContext, eventBus);
    } finally {
      const endTime = Date.now();
      console.log(`A2A JS प्रसंस्करण पूर्ण, लिया गया समय: ${endTime - startTime}ms`);
    }
  }
}

सारांश

A2A JS SDK इंटेलिजेंट एजेंट एप्लिकेशन बनाने के लिए एक शक्तिशाली उपकरण है। इस ट्यूटोरियल के माध्यम से हमने निम्नलिखित सीखा है:

  • A2A JS की मूल अवधारणाएँ और आर्किटेक्चर
  • A2A JS एजेंट बनाने और कॉन्फ़िगर करने का तरीका
  • A2A JS सर्वर और क्लाइंट डेवलपमेंट
  • A2A JS की उन्नत सुविधाएँ और बेस्ट प्रैक्टिस
  • A2A JS एप्लिकेशन समस्या निवारण के तरीके

अब आप अपना स्वयं का A2A JS एप्लिकेशन बना सकते हैं! A2A JS SDK शक्तिशाली और विस्तार योग्य इंटेलिजेंट एजेंट सिस्टम बनाने में मदद करने के लिए समृद्ध सुविधाएँ प्रदान करता है।

अधिक A2A JS संसाधनों और उदाहरणों के लिए यहाँ जाएँ:

अपनी A2A JS डेवलपमेंट यात्रा शुरू करें! 🚀