Custom LLMs से आप अपनी OpenAI API key इस्तेमाल कर सकते हैं या पूरी तरह कस्टम LLM सर्वर चला सकते हैं।

परिचय

डिफ़ॉल्ट रूप से, हम OpenAI जैसे लोकप्रिय मॉडलों के लिए अपने आंतरिक क्रेडेंशियल्स इस्तेमाल करते हैं। कस्टम LLM सर्वर इस्तेमाल करने के लिए, उसे नीचे दिए गए OpenAI-compatible request/response structures में से किसी एक के अनुरूप होना चाहिए:

• Chat Completions API (/v1/chat/completions)
• Responses API (/v1/responses)

नीचे दिए गए गाइड दोनों उपयोग मामलों को कवर करते हैं:

1. अपनी OpenAI key इस्तेमाल करें: हमारे प्लेटफ़ॉर्म के साथ अपनी OpenAI API key इस्तेमाल करें।
2. कस्टम LLM सर्वर: अपना LLM सर्वर implementation होस्ट और कनेक्ट करें।

आप जानेंगे कि कैसे:

• अपनी OpenAI API key को ElevenLabs में स्टोर करें
• ऐसा सर्वर होस्ट करें जो OpenAI के Chat Completions या Responses endpoint की नकल करता हो
• ElevenLabs को अपने कस्टम endpoint पर भेजें
• ज़रूरत के अनुसार अपने LLM को अतिरिक्त parameters भेजें

रीजनिंग सारांश

आपके endpoint को अंतिम उत्तर से अलग रीजनिंग लौटानी होगी। ElevenLabs अंतिम उत्तर से रीजनिंग जनरेट नहीं करता।

समर्थित endpoint से रीजनिंग मांगने के लिए, एजेंट की LLM सेटिंग्स में Reasoning summary चालू करें या API के ज़रिए enable_reasoning_summary सेट करें।

रीजनिंग लौटाएं

अपने endpoint से मेल खाने वाला फ़ॉर्मैट इस्तेमाल करें:

स्टोरेज, डिलीवरी और सीमाओं के लिए रीजनिंग सारांश देखें।

अपनी OpenAI key इस्तेमाल करना

कस्टम OpenAI key इंटीग्रेट करने के लिए, ElevenLabs डैशबोर्ड में अपने एजेंट की सेटिंग्स को अपने कस्टम LLM सर्वर पर पॉइंट करने के लिए अपडेट करें और अपनी OPENAI_API_KEY वाला एक सीक्रेट बनाएं:

कस्टम LLM सर्वर

कस्टम LLM सर्वर लाने के लिए, OpenAI की शैली का इस्तेमाल करके एक compatible server endpoint सेट अप करें। आप Chat Completions API (/v1/chat/completions) या Responses API (/v1/responses) में से कोई भी implement कर सकते हैं।

दोनों endpoints को Content-Type: text/event-stream के साथ SSE (Server-Sent Events) फ़ॉर्मैट में responses लौटाने होंगे।

import json
import os
import fastapi
from fastapi.responses import StreamingResponse
from openai import AsyncOpenAI
import uvicorn
import logging
from dotenv import load_dotenv
from pydantic import BaseModel
from typing import List, Optional
# Load environment variables from .env file
load_dotenv()
# Retrieve API key from environment
OPENAI_API_KEY = os.getenv('OPENAI_API_KEY')
if not OPENAI_API_KEY:
    raise ValueError("OPENAI_API_KEY not found in environment variables")
app = fastapi.FastAPI()
oai_client = AsyncOpenAI(api_key=OPENAI_API_KEY)
class Message(BaseModel):
    role: str
    content: str
class ChatCompletionRequest(BaseModel):
    messages: List[Message]
    model: str
    temperature: Optional[float] = 0.7
    max_tokens: Optional[int] = None
    stream: Optional[bool] = False
    user_id: Optional[str] = None
@app.post("/v1/chat/completions")
async def create_chat_completion(request: ChatCompletionRequest) -> StreamingResponse:
    oai_request = request.dict(exclude_none=True)
    if "user_id" in oai_request:
        oai_request["user"] = oai_request.pop("user_id")
    chat_completion_coroutine = await oai_client.chat.completions.create(**oai_request)
    async def event_stream():
        try:
            async for chunk in chat_completion_coroutine:
                # Convert the ChatCompletionChunk to a dictionary before JSON serialization
                chunk_dict = chunk.model_dump()
                yield f"data: {json.dumps(chunk_dict)}\n\n"
            yield "data: [DONE]\n\n"
        except Exception as e:
            logging.error("An error occurred: %s", str(e))
            yield f"data: {json.dumps({'error': 'Internal error occurred!'})}\n\n"
    return StreamingResponse(event_stream(), media_type="text/event-stream")
if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8013)

यह कोड या अपना सर्वर कोड चलाएं।

अपने सर्वर के लिए सार्वजनिक URL सेट करना

अपने सर्वर को एक्सेस करने योग्य बनाने के लिए, ngrok जैसे tunneling tool से सार्वजनिक URL बनाएं:

ngrok http --url=<Your url>.ngrok.app 8013

ElevenLabs CustomLLM कॉन्फ़िगर करना

अब ElevenLabs डैशबोर्ड में अपने एजेंट की सेटिंग्स को अपने कस्टम LLM सर्वर पर पॉइंट करने के लिए अपडेट करें।

अपने server URL को ngrok endpoint पर सेट करें और “Limit token usage” को 5000 पर सेट करें।

अब आप अपने LLM सर्वर के साथ एजेंट से इंटरैक्ट करना शुरू कर सकते हैं।

धीमी प्रोसेसिंग वाले LLM के लिए ऑप्टिमाइज़ करना

अगर आपके कस्टम LLM का प्रोसेसिंग समय धीमा है (शायद एजेंटिक रीजनिंग या प्री-प्रोसेसिंग की ज़रूरतों के कारण), तो आप अपने स्ट्रीमिंग रिस्पॉन्स में बफ़र शब्द लागू करके बातचीत के प्रवाह को बेहतर बना सकते हैं। यह तकनीक आपके LLM के पूरा रिस्पॉन्स जनरेट करने के दौरान बोलने की प्राकृतिक लय बनाए रखने में मदद करती है।

बफ़र शब्द

जब आपके LLM को पूरा रिस्पॉन्स प्रोसेस करने के लिए ज़्यादा समय चाहिए हो, तो "... " (एलिप्सिस के बाद एक स्पेस) पर खत्म होने वाला शुरुआती रिस्पॉन्स लौटाएं। इससे टेक्स्ट टू स्पीच सिस्टम बातचीत को सहज और सक्रिय रखते हुए प्राकृतिक प्रवाह बनाए रख पाता है। इससे ऐसे प्राकृतिक विराम बनते हैं, जो बाद के उस कॉन्टेंट में सहजता से जुड़ते हैं जिस पर LLM ज़्यादा देर तक विचार कर सकता है। अतिरिक्त स्पेस ज़रूरी है, ताकि बाद का कॉन्टेंट "..." से न जुड़ जाए, क्योंकि इससे ऑडियो में विकृति आ सकती है।

इम्प्लीमेंटेशन

बफ़र शब्द लागू करने के लिए अपने कस्टम LLM सर्वर को इस तरह बदलें:

@app.post("/v1/chat/completions")
async def create_chat_completion(request: ChatCompletionRequest) -> StreamingResponse:
    oai_request = request.dict(exclude_none=True)
    if "user_id" in oai_request:
        oai_request["user"] = oai_request.pop("user_id")
    async def event_stream():
        try:
            # Send initial buffer chunk while processing
            initial_chunk = {
                "id": "chatcmpl-buffer",
                "object": "chat.completion.chunk",
                "created": 1234567890,
                "model": request.model,
                "choices": [{
                    "delta": {"content": "Let me think about that... "},
                    "index": 0,
                    "finish_reason": None
                }]
            }
            yield f"data: {json.dumps(initial_chunk)}\n\n"
            # Process the actual LLM response
            chat_completion_coroutine = await oai_client.chat.completions.create(**oai_request)
            async for chunk in chat_completion_coroutine:
                chunk_dict = chunk.model_dump()
                yield f"data: {json.dumps(chunk_dict)}\n\n"
            yield "data: [DONE]\n\n"
        except Exception as e:
            logging.error("An error occurred: %s", str(e))
            yield f"data: {json.dumps({'error': 'Internal error occurred!'})}\n\n"
    return StreamingResponse(event_stream(), media_type="text/event-stream")

सिस्टम टूल्स इंटीग्रेशन

आपका कस्टम LLM बातचीत के प्रवाह और स्थिति को नियंत्रित करने के लिए सिस्टम टूल्स ट्रिगर कर सकता है। आपके एजेंट में कॉन्फ़िगर होने पर ये टूल्स आपके चैट कंप्लीशन अनुरोधों के tools पैरामीटर में अपने-आप शामिल हो जाते हैं।

सिस्टम टूल्स कैसे काम करते हैं

1. LLM का निर्णय: आपका कस्टम LLM बातचीत के संदर्भ के आधार पर तय करता है कि इन टूल्स को कब कॉल करना है
2. टूल रिस्पॉन्स: LLM स्टैंडर्ड OpenAI फ़ॉर्मेट में फ़ंक्शन कॉल के साथ रिस्पॉन्ड करता है
3. बैकएंड प्रोसेसिंग: ElevenLabs टूल कॉल्स को प्रोसेस करता है और बातचीत की स्थिति अपडेट करता है

सिस्टम टूल्स के बारे में ज़्यादा जानकारी के लिए, हमारी गाइड देखें

उपलब्ध सिस्टम टूल्स

{
  "type": "function",
  "function": {
    "name": "end_call",
    "arguments": "{\"reason\": \"Task completed successfully\", \"message\": \"Thank you for using our service. Have a great day!\"}"
  }
}

{
  "type": "function",
  "function": {
    "name": "language_detection",
    "arguments": "{\"reason\": \"User requested Spanish\", \"language\": \"es\"}"
  }
}

{
  "type": "function",
  "function": {
    "name": "transfer_to_agent",
    "arguments": "{\"reason\": \"User needs billing support\", \"agent_number\": 0}"
  }
}

{
  "type": "function",
  "function": {
    "name": "transfer_to_number",
    "arguments": "{\"reason\": \"Complex billing issue\", \"transfer_number\": \"+15551234567\", \"client_message\": \"I'm transferring you to a billing specialist who can help with your account.\", \"agent_message\": \"Customer has a complex billing dispute about order #12345 from last month.\"}"
  }
}

{
  "type": "function",
  "function": {
    "name": "skip_turn",
    "arguments": "{\"reason\": \"User requested time to think\"}"
  }
}

{
  "type": "function",
  "function": {
    "name": "voicemail_detection",
    "arguments": "{\"reason\": \"Automated greeting detected with request to leave message\"}"
  }
}

सिस्टम टूल्स के साथ उदाहरण अनुरोध

सिस्टम टूल्स कॉन्फ़िगर होने पर, आपके कस्टम LLM को ऐसे अनुरोध मिलेंगे जिनमें स्टैंडर्ड OpenAI फ़ॉर्मेट में टूल्स शामिल होते हैं:

{
  "messages": [
    {
      "role": "system",
      "content": "You are a helpful assistant. You have access to system tools for managing conversations."
    },
    {
      "role": "user",
      "content": "I think we're done here, thanks for your help!"
    }
  ],
  "model": "your-custom-model",
  "temperature": 0.7,
  "max_tokens": 1000,
  "stream": true,
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "end_call",
        "description": "Call this function to end the current conversation when the main task has been completed...",
        "parameters": {
          "type": "object",
          "properties": {
            "reason": {
              "type": "string",
              "description": "The reason for the tool call."
            },
            "message": {
              "type": "string",
              "description": "A farewell message to send to the user along right before ending the call."
            }
          },
          "required": ["reason"]
        }
      }
    },
    {
      "type": "function",
      "function": {
        "name": "language_detection",
        "description": "Change the conversation language when the user expresses a language preference explicitly...",
        "parameters": {
          "type": "object",
          "properties": {
            "reason": {
              "type": "string",
              "description": "The reason for the tool call."
            },
            "language": {
              "type": "string",
              "description": "The language to switch to. Must be one of language codes in tool description."
            }
          },
          "required": ["reason", "language"]
        }
      }
    },
    {
      "type": "function",
      "function": {
        "name": "skip_turn",
        "description": "Skip a turn when the user explicitly indicates they need a moment to think...",
        "parameters": {
          "type": "object",
          "properties": {
            "reason": {
              "type": "string",
              "description": "Optional free-form reason explaining why the pause is needed."
            }
          },
          "required": []
        }
      }
    }
  ]
}

अतिरिक्त सुविधाएं

from elevenlabs.conversational_ai.conversation import Conversation, ConversationInitiationData
extra_body_for_convai = {
    "UUID": "123e4567-e89b-12d3-a456-426614174000",
    "parameter-1": "value-1",
    "parameter-2": "value-2",
}
config = ConversationInitiationData(
    extra_body=extra_body_for_convai,
)

import json
import os
import fastapi
from fastapi.responses import StreamingResponse
from fastapi import Request
from openai import AsyncOpenAI
import uvicorn
import logging
from dotenv import load_dotenv
from pydantic import BaseModel
from typing import List, Optional
# Load environment variables from .env file
load_dotenv()
# Retrieve API key from environment
OPENAI_API_KEY = os.getenv('OPENAI_API_KEY')
if not OPENAI_API_KEY:
    raise ValueError("OPENAI_API_KEY not found in environment variables")
app = fastapi.FastAPI()
oai_client = AsyncOpenAI(api_key=OPENAI_API_KEY)
class Message(BaseModel):
    role: str
    content: str
class ChatCompletionRequest(BaseModel):
    messages: List[Message]
    model: str
    temperature: Optional[float] = 0.7
    max_tokens: Optional[int] = None
    stream: Optional[bool] = False
    user_id: Optional[str] = None
    elevenlabs_extra_body: Optional[dict] = None
@app.post("/v1/chat/completions")
async def create_chat_completion(request: ChatCompletionRequest) -> StreamingResponse:
    oai_request = request.dict(exclude_none=True)
    print(oai_request)
    if "user_id" in oai_request:
        oai_request["user"] = oai_request.pop("user_id")
    if "elevenlabs_extra_body" in oai_request:
        oai_request.pop("elevenlabs_extra_body")
    chat_completion_coroutine = await oai_client.chat.completions.create(**oai_request)
    async def event_stream():
        try:
            async for chunk in chat_completion_coroutine:
                chunk_dict = chunk.model_dump()
                yield f"data: {json.dumps(chunk_dict)}\n\n"
            yield "data: [DONE]\n\n"
        except Exception as e:
            logging.error("An error occurred: %s", str(e))
            yield f"data: {json.dumps({'error': 'Internal error occurred!'})}\n\n"
    return StreamingResponse(event_stream(), media_type="text/event-stream")
if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8013)

{
  "messages": [
    {
      "role": "system",
      "content": "\n  <Redacted>"
    },
    {
      "role": "assistant",
      "content": "Hey I'm currently unavailable."
    },
    {
      "role": "user",
      "content": "Hey, who are you?"
    }
  ],
  "model": "gpt-4o",
  "temperature": 0.5,
  "max_tokens": 5000,
  "stream": true,
  "elevenlabs_extra_body": {
    "UUID": "123e4567-e89b-12d3-a456-426614174000",
    "parameter-1": "value-1",
    "parameter-2": "value-2"
  }
}