चैट SDK

npm install @odin-ai-staging/sdk

import { ChatSDK } from '@odin-ai-staging/sdk';

// SDK को आरंभ करें
const chatSDK = new ChatSDK({
  baseUrl: 'https://your-api-endpoint.com/',
  projectId: 'your-project-id',
  apiKey: 'your-api-key',
  apiSecret: 'your-api-secret'
});

// चैट बनाएँ और संदेश भेजें
async function quickExample() {
  // एक नई चैट बनाएँ
  const chat = await chatSDK.createChat('मेरी पहली चैट');
  
  // संदेश भेजें
  const response = await chatSDK.sendMessage('नमस्ते, आप मेरी कैसे मदद कर सकते हैं?', {
    chatId: chat.chat_id
  });
  
  console.log('AI प्रतिक्रिया:', response.message);
}

interface ChatSDKConfig {
  baseUrl: string;          // API एंडपॉइंट URL
  projectId: string;        // आपका परियोजना पहचानकर्ता
  apiKey?: string;          // प्रमाणीकरण के लिए API key
  apiSecret?: string;       // प्रमाणीकरण के लिए API secret
  accessToken?: string;     // वेब ऐप उपयोग के लिए access token
}

const chatSDK = new ChatSDK({
  baseUrl: 'https://api.example.com/',
  projectId: 'proj_123',
  apiKey: 'your-api-key',
  apiSecret: 'your-api-secret'
});

const chatSDK = new ChatSDK({
  baseUrl: 'https://api.example.com/',
  projectId: 'proj_123',
  accessToken: 'your-access-token'
});

async createChat(
  name?: string,           // वैकल्पिक चैट नाम (डिफ़ॉल्ट "Untitled")
  documentKeys?: string[]  // ज्ञान आधार संदर्भ के लिए वैकल्पिक दस्तावेज़ keys
): Promise<CreateChatResponse>

// एक बुनियादी चैट बनाएँ
const chat = await chatSDK.createChat('ग्राहक सहायता चैट');

// ज्ञान आधार संदर्भ के साथ चैट बनाएँ
const chatWithDocs = await chatSDK.createChat(
  'उत्पाद दस्तावेज़ चैट',
  ['doc_key_1', 'doc_key_2']
);

async listChats(
  cursor?: number,  // पेजिनेशन के लिए वैकल्पिक कर्सर
  limit?: number    // लौटाने के लिए चैट्स की संख्या (डिफ़ॉल्ट: 30, अधिकतम: 100)
): Promise<ListChatsResponse>

// पहली 10 चैट्स प्राप्त करें
const chats = await chatSDK.listChats(undefined, 10);

// कर्सर का उपयोग करके अगला पेज प्राप्त करें
if (chats.next_cursor) {
  const nextPage = await chatSDK.listChats(chats.next_cursor, 10);
}

async getChatHistory(chatId: string): Promise<ChatHistoryResponse>

const chatHistory = await chatSDK.getChatHistory('chat_123');
console.log('संदेश:', chatHistory.messages);

async deleteChat(chatId: string): Promise<void>

await chatSDK.deleteChat('chat_123');

async updateChatName(chatId: string, newName: string): Promise<void>

await chatSDK.updateChatName('chat_123', 'अपडेटेड चैट नाम');

async sendMessage(
  message: string,
  options?: SendMessageOptions
): Promise<SendMessageResponse>

interface SendMessageOptions {
  chatId?: string;          // लक्ष्य चैट ID
  agentType?: AgentType;    // उपयोग करने के लिए AI एजेंट प्रकार
  agentId?: string;         // विशिष्ट एजेंट ID
  documentKeys?: string[];  // ज्ञान आधार दस्तावेज़
  images?: File[];          // चित्र अनुलग्नक
  metadata?: Record<string, any>;  // कस्टम metadata
  modelName?: ModelName;    // उपयोग करने के लिए AI मॉडल
  useKnowledgebase?: boolean;      // ज्ञान आधार सक्षम करें
  isTest?: boolean;         // परीक्षण मोड फ़्लैग
  googleSearch?: boolean;   // वेब खोज सक्षम करें
  formatInstructions?: string;     // प्रतिक्रिया प्रारूप मार्गदर्शन
  ignoreChatHistory?: boolean;     // वार्तालाप इतिहास अनदेखा करें
  exampleJson?: string;     // संरचित प्रतिक्रियाओं के लिए उदाहरण JSON
  skipStream?: boolean;     // स्ट्रीमिंग अक्षम करें
}

// बुनियादी संदेश
const response = await chatSDK.sendMessage('कृत्रिम बुद्धिमत्ता क्या है?', {
  chatId: 'chat_123'
});

// विकल्पों के साथ उन्नत संदेश
const advancedResponse = await chatSDK.sendMessage(
  'इस डेटा का विश्लेषण करें और अंतर्दृष्टि प्रदान करें',
  {
    chatId: 'chat_123',
    modelName: 'gpt-4o',
    useKnowledgebase: true,
    googleSearch: true,
    formatInstructions: 'प्रतिक्रिया बुलेट पॉइंट्स में प्रदान करें'
  }
);

async sendFeedback(
  messageId: string,
  chatId: string,
  feedback: boolean  // true = पसंद, false = नापसंद
): Promise<void>

// सकारात्मक प्रतिक्रिया
await chatSDK.sendFeedback('msg_123', 'chat_123', true);

// नकारात्मक प्रतिक्रिया
await chatSDK.sendFeedback('msg_123', 'chat_123', false);

async sendMessageStream(
  message: string,
  options: SendMessageOptions & StreamCallbacks
): Promise<void>

interface StreamCallbacks {
  onChunk?: (chunk: string) => void;           // टेक्स्ट चंक्स
  onMessageObject?: (messageObject: any) => void;  // संरचित डेटा
  onComplete?: (message: Message) => void;     // अंतिम संदेश
  onError?: (error: Error) => void;           // त्रुटि हैंडलर
  onChatNameUpdate?: (chatName: string) => void;   // चैट नाम परिवर्तन
  onDocumentChunk?: (chunk: string) => void;  // दस्तावेज़ प्रसंस्करण अपडेट
  onMessageEnd?: () => void;                  // स्ट्रीम पूर्णता
}

await chatSDK.sendMessageStream(
  'मुझे मशीन लर्निंग के बारे में बताएँ',
  {
    chatId: 'chat_123',
    onChunk: (chunk) => {
      console.log('चंक:', chunk);
      updateUI(chunk);
    },
    onComplete: (message) => {
      console.log('पूर्ण संदेश:', message);
      finalizeUI(message);
    },
    onError: (error) => {
      console.error('स्ट्रीम त्रुटि:', error);
      showError(error.message);
    }
  }
);

interface APIError {
  message: string;  // त्रुटि विवरण
  status: number;   // HTTP स्थिति कोड
  detail?: string;  // अतिरिक्त त्रुटि विवरण
}

try {
  const response = await chatSDK.sendMessage('नमस्ते');
} catch (error) {
  if (error instanceof APIError) {
    console.error(`API त्रुटि ${error.status}: ${error.message}`);
    if (error.detail) {
      console.error('विवरण:', error.detail);
    }
  } else {
    console.error('अप्रत्याशित त्रुटि:', error);
  }
}

import { ChatSDK } from '@odin-ai-staging/sdk';

class SimpleChatApp {
  private chatSDK: ChatSDK;
  private currentChatId?: string;

  constructor() {
    this.chatSDK = new ChatSDK({
      baseUrl: process.env.API_BASE_URL,
      projectId: process.env.PROJECT_ID,
      apiKey: process.env.API_KEY,
      apiSecret: process.env.API_SECRET
    });
  }

  async startNewChat(name: string = 'नई चैट') {
    try {
      const chat = await this.chatSDK.createChat(name);
      this.currentChatId = chat.chat_id;
      console.log(`चैट बनाई: ${chat.name} (${chat.chat_id})`);
      return chat;
    } catch (error) {
      console.error('चैट बनाने में विफल:', error);
      throw error;
    }
  }

  async sendMessage(message: string) {
    if (!this.currentChatId) {
      await this.startNewChat();
    }

    try {
      const response = await this.chatSDK.sendMessage(message, {
        chatId: this.currentChatId,
        modelName: 'gpt-4o-mini'
      });

      console.log('उपयोगकर्ता:', message);
      console.log('AI:', response.message);
      
      return response;
    } catch (error) {
      console.error('संदेश भेजने में विफल:', error);
      throw error;
    }
  }

  async getChatList() {
    try {
      const chats = await this.chatSDK.listChats();
      return chats.chats;
    } catch (error) {
      console.error('चैट सूची प्राप्त करने में विफल:', error);
      throw error;
    }
  }
}

const app = new SimpleChatApp();
await app.sendMessage('नमस्ते, आप कैसे हैं?');

import { ChatSDK, StreamCallbacks } from '@odin-ai-staging/sdk';

class StreamingChat {
  private chatSDK: ChatSDK;
  private messageElement: HTMLElement;

  constructor(messageElement: HTMLElement) {
    this.messageElement = messageElement;
    this.chatSDK = new ChatSDK({
      baseUrl: 'https://your-api.com/',
      projectId: 'your-project-id',
      accessToken: 'your-access-token'
    });
  }

  async sendStreamingMessage(message: string, chatId: string) {
    this.messageElement.innerHTML = '';

    const callbacks: StreamCallbacks = {
      onChunk: (chunk: string) => {
        this.messageElement.innerHTML += chunk;
        this.messageElement.scrollIntoView();
      },
      onMessageObject: (messageObj: any) => {
        if (messageObj.image_urls) {
          this.displayImages(messageObj.image_urls);
        }
      },
      onComplete: (message: any) => {
        console.log('संदेश पूर्ण:', message);
        this.finalizeMessage(message);
      },
      onError: (error: Error) => {
        console.error('स्ट्रीमिंग त्रुटि:', error);
        this.messageElement.innerHTML = `त्रुटि: ${error.message}`;
      },
      onChatNameUpdate: (chatName: string) => {
        document.title = chatName;
      }
    };

    try {
      await this.chatSDK.sendMessageStream(message, {
        chatId,
        modelName: 'gpt-4o',
        useKnowledgebase: true,
        ...callbacks
      });
    } catch (error) {
      console.error('स्ट्रीमिंग संदेश भेजने में विफल:', error);
    }
  }

  private displayImages(imageUrls: string[]) {
    imageUrls.forEach(url => {
      const img = document.createElement('img');
      img.src = url;
      img.style.maxWidth = '100%';
      this.messageElement.appendChild(img);
    });
  }

  private finalizeMessage(message: any) {
    const feedbackDiv = document.createElement('div');
    feedbackDiv.innerHTML = `
      <button onclick="this.provideFeedback('${message.id}', true)">👍</button>
      <button onclick="this.provideFeedback('${message.id}', false)">👎</button>
    `;
    this.messageElement.appendChild(feedbackDiv);
  }

  async provideFeedback(messageId: string, isPositive: boolean) {
    try {
      await this.chatSDK.sendFeedback(messageId, 'chat_id', isPositive);
      console.log('प्रतिक्रिया सफलतापूर्वक भेजी गई');
    } catch (error) {
      console.error('प्रतिक्रिया भेजने में विफल:', error);
    }
  }
}

import { ChatSDK } from '@odin-ai-staging/sdk';

class KnowledgeBasedChat {
  private chatSDK: ChatSDK;

  constructor() {
    this.chatSDK = new ChatSDK({
      baseUrl: process.env.API_BASE_URL,
      projectId: process.env.PROJECT_ID,
      apiKey: process.env.API_KEY,
      apiSecret: process.env.API_SECRET
    });
  }

  async createDocumentChat(documentKeys: string[], chatName?: string) {
    try {
      const chat = await this.chatSDK.createChat(
        chatName || 'दस्तावेज़ Q&A',
        documentKeys
      );
      
      console.log(`${documentKeys.length} दस्तावेज़ों के साथ दस्तावेज़ चैट बनाई`);
      return chat;
    } catch (error) {
      console.error('दस्तावेज़ चैट बनाने में विफल:', error);
      throw error;
    }
  }

  async askDocumentQuestion(question: string, chatId: string, documentKeys?: string[]) {
    try {
      const response = await this.chatSDK.sendMessage(question, {
        chatId,
        documentKeys,
        useKnowledgebase: true,
        agentType: 'document_agent',
        formatInstructions: 'अपने स्रोतों के लिए उद्धरण प्रदान करें'
      });

      if (response.message.sources) {
        console.log('स्रोत:', response.message.sources);
      }

      return response;
    } catch (error) {
      console.error('दस्तावेज़ प्रश्न पूछने में विफल:', error);
      throw error;
    }
  }
}

const kbChat = new KnowledgeBasedChat();
const chat = await kbChat.createDocumentChat(['doc_1', 'doc_2'], 'उत्पाद FAQ');
const answer = await kbChat.askDocumentQuestion(
  'उत्पाद की प्रमुख विशेषताएँ क्या हैं?',
  chat.chat_id
);

try {
  const response = await chatSDK.sendMessage(message, options);
} catch (error) {
  if (error instanceof APIError) {
    console.error(`API त्रुटि: ${error.message}`);
  } else {
    console.error('अप्रत्याशित त्रुटि:', error);
  }
}

await chatSDK.sendMessageStream(longQuery, {
  onChunk: (chunk) => updateUI(chunk),
  onComplete: (message) => finalizeUI(message)
});

class OptimizedChatManager {
  private chatCache = new Map<string, any>();
  private currentChatId?: string;

  async getOrCreateChat(name?: string) {
    if (this.currentChatId) {
      return this.currentChatId;
    }
    const chat = await this.chatSDK.createChat(name);
    this.currentChatId = chat.chat_id;
    return this.currentChatId;
  }

  async getCachedChatHistory(chatId: string) {
    if (this.chatCache.has(chatId)) {
      return this.chatCache.get(chatId);
    }
    const history = await this.chatSDK.getChatHistory(chatId);
    this.chatCache.set(chatId, history);
    return history;
  }
}

// अच्छा: एनवायरनमेंट वेरिएबल्स का उपयोग करें
const chatSDK = new ChatSDK({
  baseUrl: process.env.ODIN_API_BASE_URL,
  projectId: process.env.ODIN_PROJECT_ID,
  apiKey: process.env.ODIN_API_KEY,
  apiSecret: process.env.ODIN_API_SECRET
});

// बुरा: क्रेडेंशियल्स हार्डकोड करें
const chatSDK = new ChatSDK({
  baseUrl: 'https://api.example.com',
  projectId: 'hardcoded-project-id',
  apiKey: 'hardcoded-api-key',
  apiSecret: 'hardcoded-secret'
});

class ChatApplication {
  private activeStreams = new Set<AbortController>();

  async sendStreamingMessage(message: string, options: any) {
    const controller = new AbortController();
    this.activeStreams.add(controller);
    try {
      await this.chatSDK.sendMessageStream(message, {
        ...options,
        signal: controller.signal
      });
    } finally {
      this.activeStreams.delete(controller);
    }
  }

  cleanup() {
    this.activeStreams.forEach(controller => controller.abort());
    this.activeStreams.clear();
  }
}