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

किसी Custom LLM को Realtime मॉडल के साथ इस्तेमाल नहीं किया जा सकता।

अवलोकन

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

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

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

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

आप सीखेंगे कि कैसे:

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

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

आपके एंडपॉइंट को अंतिम जवाब से अलग रीजनिंग लौटानी चाहिए। ElevenLabs अंतिम जवाब से रीजनिंग जनरेट नहीं करता।

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

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

अपने एंडपॉइंट के अनुरूप फ़ॉर्मैट इस्तेमाल करें:

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

अपनी OpenAI कुंजी इस्तेमाल करना

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

Custom LLM सर्वर

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

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

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 जैसे टनलिंग टूल का उपयोग करके एक सार्वजनिक URL बनाएँ:

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

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

अब, ElevenLabs डैशबोर्ड में अपनी एजेंट सेटिंग्स अपडेट करें ताकि वे आपके Custom LLM सर्वर की ओर जाएँ।

अपने सर्वर URL को ngrok एंडपॉइंट पर भेजें और “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"
  }
}