प्लगइन का उपयोग कैसे करें

Runtime AI Chatbot Integrator दो मुख्य कार्यक्षमताएं प्रदान करता है: टेक्स्ट-टू-टेक्स्ट चैट और टेक्स्ट-टू-स्पीच (TTS)। दोनों सुविधाएं एक समान वर्कफ़्लो का पालन करती हैं:

1. अपने API प्रदाता टोकन को पंजीकृत करें
2. फीचर-विशिष्ट सेटिंग्स कॉन्फ़िगर करें
3. अनुरोध भेजें और प्रतिक्रियाओं को प्रोसेस करें

प्रदाता टोकन पंजीकृत करें

किसी भी अनुरोध को भेजने से पहले, RegisterProviderToken फ़ंक्शन का उपयोग करके अपने API प्रदाता टोकन को पंजीकृत करें।

Blueprint

C++

// Register an OpenAI provider token, as an example
UAIChatbotCredentialsManager::RegisterProviderToken(
    EAIChatbotIntegratorOrgs::OpenAI, 
    TEXT("sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")
);

टेक्स्ट-टू-टेक्स्ट चैट फंक्शनैलिटी

प्लगइन प्रत्येक प्रदाता के लिए दो चैट अनुरोध मोड का समर्थन करता है:

नॉन-स्ट्रीमिंग चैट अनुरोध

एक ही कॉल में पूर्ण प्रतिक्रिया प्राप्त करें।

OpenAI

Blueprint

C++

// Example of sending a non-streaming chat request to OpenAI
FChatbotIntegrator_OpenAISettings Settings;
Settings.Messages.Add(FChatbotIntegrator_OpenAIMessage(
    EChatbotIntegrator_OpenAIRole::SYSTEM, 
    TEXT("You are a helpful assistant.")
));
Settings.Messages.Add(FChatbotIntegrator_OpenAIMessage(
    EChatbotIntegrator_OpenAIRole::USER, 
    TEXT("What is the capital of France?")
));

UAIChatbotIntegratorOpenAI::SendChatRequestNative(
    Settings, 
    FOnOpenAIChatCompletionResponseNative::CreateWeakLambda(
        this, 
        [this](const FString& Response, const FChatbotIntegratorErrorStatus& ErrorStatus)
        {
            UE_LOG(LogTemp, Log, TEXT("Chat completion response: %s, Error: %d: %s"), 
                *Response, ErrorStatus.bIsError, *ErrorStatus.ErrorMessage);
        }
    )
);

DeepSeek

Blueprint

C++

// Example of sending a non-streaming chat request to DeepSeek
FChatbotIntegrator_DeepSeekSettings Settings;
Settings.Messages.Add(FChatbotIntegrator_DeepSeekMessage(
    EChatbotIntegrator_DeepSeekRole::SYSTEM, 
    TEXT("You are a helpful assistant.")
));
Settings.Messages.Add(FChatbotIntegrator_DeepSeekMessage(
    EChatbotIntegrator_DeepSeekRole::USER, 
    TEXT("What is the capital of France?")
));

UAIChatbotIntegratorDeepSeek::SendChatRequestNative(
    Settings, 
    FOnDeepSeekChatCompletionResponseNative::CreateWeakLambda(
        this, 
        [this](const FString& Reasoning, const FString& Content, const FChatbotIntegratorErrorStatus& ErrorStatus)
        {
            UE_LOG(LogTemp, Log, TEXT("Chat completion reasoning: %s, Content: %s, Error: %d: %s"), 
                *Reasoning, *Content, ErrorStatus.bIsError, *ErrorStatus.ErrorMessage);
        }
    )
);

Claude

Blueprint

C++

// Example of sending a non-streaming chat request to Claude
FChatbotIntegrator_ClaudeSettings Settings;
Settings.Messages.Add(FChatbotIntegrator_ClaudeMessage(
    EChatbotIntegrator_ClaudeRole::SYSTEM, 
    TEXT("You are a helpful assistant.")
));
Settings.Messages.Add(FChatbotIntegrator_ClaudeMessage(
    EChatbotIntegrator_ClaudeRole::USER, 
    TEXT("What is the capital of France?")
));

UAIChatbotIntegratorClaudeStream::SendStreamingChatRequestNative(
    Settings, 
    FOnClaudeChatCompletionStreamNative::CreateWeakLambda(
        this, 
        [this](const FString& Response, bool IsFinalChunk, const FChatbotIntegratorErrorStatus& ErrorStatus)
        {
            UE_LOG(LogTemp, Log, TEXT("Streaming chat completion response: %s, IsFinalChunk: %d, Error: %d: %s"), 
                *Response, IsFinalChunk, ErrorStatus.bIsError, *ErrorStatus.ErrorMessage);
        }
    )
);

स्ट्रीमिंग चैट अनुरोध

अधिक गतिशील इंटरैक्शन के लिए रियल-टाइम में प्रतिक्रिया के टुकड़े प्राप्त करें।

OpenAI

Blueprint

C++

// Example of sending a streaming chat request to OpenAI
FChatbotIntegrator_OpenAISettings Settings;
Settings.Messages.Add(FChatbotIntegrator_OpenAIMessage(
    EChatbotIntegrator_OpenAIRole::SYSTEM, 
    TEXT("You are a helpful assistant.")
));
Settings.Messages.Add(FChatbotIntegrator_OpenAIMessage(
    EChatbotIntegrator_OpenAIRole::USER, 
    TEXT("What is the capital of France?")
));

UAIChatbotIntegratorOpenAIStream::SendStreamingChatRequestNative(
    Settings, 
    FOnOpenAIChatCompletionStreamNative::CreateWeakLambda(
        this, 
        [this](const FString& Response, bool IsFinalChunk, const FChatbotIntegratorErrorStatus& ErrorStatus)
        {
            UE_LOG(LogTemp, Log, TEXT("Streaming chat completion response: %s, IsFinalChunk: %d, Error: %d: %s"), 
                *Response, IsFinalChunk, ErrorStatus.bIsError, *ErrorStatus.ErrorMessage);
        }
    )
);

DeepSeek

Blueprint

C++

// Example of sending a streaming chat request to DeepSeek
FChatbotIntegrator_DeepSeekSettings Settings;
Settings.Messages.Add(FChatbotIntegrator_DeepSeekMessage(
    EChatbotIntegrator_DeepSeekRole::SYSTEM, 
    TEXT("You are a helpful assistant.")
));
Settings.Messages.Add(FChatbotIntegrator_DeepSeekMessage(
    EChatbotIntegrator_DeepSeekRole::USER, 
    TEXT("What is the capital of France?")
));

UAIChatbotIntegratorDeepSeekStream::SendStreamingChatRequestNative(
    Settings, 
    FOnDeepSeekChatCompletionStreamNative::CreateWeakLambda(
        this, 
        [this](const FString& ReasoningChunk, const FString& ContentChunk, 
               bool IsReasoningFinalChunk, bool IsContentFinalChunk, 
               const FChatbotIntegratorErrorStatus& ErrorStatus)
        {
            UE_LOG(LogTemp, Log, TEXT("Streaming chat completion reasoning chunk: %s, Content chunk: %s, IsReasoningFinalChunk: %d, IsContentFinalChunk: %d, Error: %d: %s"), 
                *ReasoningChunk, *ContentChunk, IsReasoningFinalChunk, IsContentFinalChunk, 
                ErrorStatus.bIsError, *ErrorStatus.ErrorMessage);
        }
    )
);

Claude

Blueprint

C++

// Example of sending a streaming chat request to Claude
FChatbotIntegrator_ClaudeSettings Settings;
Settings.Messages.Add(FChatbotIntegrator_ClaudeMessage(
    EChatbotIntegrator_ClaudeRole::SYSTEM, 
    TEXT("You are a helpful assistant.")
));
Settings.Messages.Add(FChatbotIntegrator_ClaudeMessage(
    EChatbotIntegrator_ClaudeRole::USER, 
    TEXT("What is the capital of France?")
));

UAIChatbotIntegratorClaudeStream::SendStreamingChatRequestNative(
    Settings, 
    FOnClaudeChatCompletionStreamNative::CreateWeakLambda(
        this, 
        [this](const FString& Response, bool IsFinalChunk, const FChatbotIntegratorErrorStatus& ErrorStatus)
        {
            UE_LOG(LogTemp, Log, TEXT("Streaming chat completion response: %s, IsFinalChunk: %d, Error: %d: %s"), 
                *Response, IsFinalChunk, ErrorStatus.bIsError, *ErrorStatus.ErrorMessage);
        }
    )
);

टेक्स्ट-टू-स्पीच (TTS) फंक्शनैलिटी

अग्रणी TTS प्रदाताओं का उपयोग करके टेक्स्ट को उच्च-गुणवत्ता वाले स्पीच ऑडियो में बदलें। यह प्लगइन कच्चे ऑडियो डेटा (TArray<uint8>) लौटाता है जिसे आप अपने प्रोजेक्ट की आवश्यकताओं के अनुसार प्रोसेस कर सकते हैं।

नीचे दिए गए उदाहरण Runtime Audio Importer प्लगइन का उपयोग करके प्लेबैक के लिए ऑडियो प्रोसेसिंग दिखाते हैं (ऑडियो इम्पोर्टिंग डॉक्युमेंटेशन देखें), Runtime AI Chatbot Integrator लचीला बनाया गया है। प्लगइन केवल कच्चा ऑडियो डेटा लौटाता है, जिससे आपको अपने विशिष्ट उपयोग के मामले के लिए इसे प्रोसेस करने की पूरी स्वतंत्रता मिलती है, जिसमें ऑडियो प्लेबैक, फाइल में सेव करना, आगे की ऑडियो प्रोसेसिंग, अन्य सिस्टम को ट्रांसमिट करना, कस्टम विज़ुअलाइज़ेशन और बहुत कुछ शामिल हो सकता है।

नॉन-स्ट्रीमिंग TTS रिक्वेस्ट्स

नॉन-स्ट्रीमिंग TTS रिक्वेस्ट्स पूरे टेक्स्ट के प्रोसेस होने के बाद एक ही प्रतिक्रिया में पूरा ऑडियो डेटा लौटाती हैं। यह दृष्टिकोण छोटे टेक्स्ट के लिए उपयुक्त है जहां पूरे ऑडियो के लिए इंतजार करना समस्याग्रस्त नहीं है।

OpenAI TTS

Blueprint

C++

// Example of sending a TTS request to OpenAI
FChatbotIntegrator_OpenAITTSSettings TTSSettings;
TTSSettings.Input = TEXT("Hello, this is a test of text-to-speech functionality.");
TTSSettings.Voice = EChatbotIntegrator_OpenAITTSVoice::NOVA;
TTSSettings.Speed = 1.0f;
TTSSettings.ResponseFormat = EChatbotIntegrator_OpenAITTSFormat::MP3;

UAIChatbotIntegratorOpenAITTS::SendTTSRequestNative(
	TTSSettings, 
	FOnElevenLabsTTSResponseNative::CreateWeakLambda(
		this, 
		[this](const TArray<uint8>& AudioData, const FChatbotIntegratorErrorStatus& ErrorStatus)
		{
			if (!ErrorStatus.bIsError)
			{
				// Process the audio data using Runtime Audio Importer plugin
				// Example: Import the audio data as a sound wave
				UE_LOG(LogTemp, Log, TEXT("Received TTS audio data: %d bytes"), AudioData.Num());

				// Audio data can be imported using Runtime Audio Importer plugin
				URuntimeAudioImporterLibrary* RuntimeAudioImporter = URuntimeAudioImporterLibrary::CreateRuntimeAudioImporter();
				RuntimeAudioImporter->AddToRoot();
				RuntimeAudioImporter->OnResultNative.AddWeakLambda(this, [this](URuntimeAudioImporterLibrary* Importer, UImportedSoundWave* ImportedSoundWave, ERuntimeImportStatus Status)
				{
					if (Status == ERuntimeImportStatus::SuccessfulImport)
					{
						UE_LOG(LogTemp, Warning, TEXT("Successfully imported audio with sound wave %s"), *ImportedSoundWave->GetName());
						// Here you can handle ImportedSoundWave playback, like "UGameplayStatics::PlaySound2D(GetWorld(), ImportedSoundWave);"
					}
					else
					{
						UE_LOG(LogTemp, Error, TEXT("Failed to import audio"));
					}

					Importer->RemoveFromRoot();
				});
				RuntimeAudioImporter->ImportAudioFromBuffer(AudioData, ERuntimeAudioFormat::Mp3);
			}
			else
			{
				UE_LOG(LogTemp, Error, TEXT("TTS request failed: %s"), *ErrorStatus.ErrorMessage);
			}
		}
	)
);

ElevenLabs TTS

Blueprint

C++

// Example of sending a TTS request to ElevenLabs
FChatbotIntegrator_ElevenLabsTTSSettings TTSSettings;
TTSSettings.Text = TEXT("Hello, this is a test of text-to-speech functionality.");
TTSSettings.VoiceID = TEXT("your-voice-id"); // Replace with actual voice ID
TTSSettings.Model = EChatbotIntegrator_ElevenLabsTTSModel::ELEVEN_TURBO_V2;
TTSSettings.OutputFormat = EChatbotIntegrator_ElevenLabsTTSFormat::MP3_44100_128;

UAIChatbotIntegratorElevenLabsTTS::SendTTSRequestNative(
	TTSSettings, 
	FOnElevenLabsTTSResponseNative::CreateWeakLambda(
		this, 
		[this](const TArray<uint8>& AudioData, const FChatbotIntegratorErrorStatus& ErrorStatus)
		{
			if (!ErrorStatus.bIsError)
			{
				// Process the audio data using Runtime Audio Importer plugin
				// Example: Import the audio data as a sound wave
				UE_LOG(LogTemp, Log, TEXT("Received TTS audio data: %d bytes"), AudioData.Num());

				// Audio data can be imported using Runtime Audio Importer plugin
				URuntimeAudioImporterLibrary* RuntimeAudioImporter = URuntimeAudioImporterLibrary::CreateRuntimeAudioImporter();
				RuntimeAudioImporter->AddToRoot();
				RuntimeAudioImporter->OnResultNative.AddWeakLambda(this, [this](URuntimeAudioImporterLibrary* Importer, UImportedSoundWave* ImportedSoundWave, ERuntimeImportStatus Status)
				{
					if (Status == ERuntimeImportStatus::SuccessfulImport)
					{
						UE_LOG(LogTemp, Warning, TEXT("Successfully imported audio with sound wave %s"), *ImportedSoundWave->GetName());
						// Here you can handle ImportedSoundWave playback, like "UGameplayStatics::PlaySound2D(GetWorld(), ImportedSoundWave);"
					}
					else
					{
						UE_LOG(LogTemp, Error, TEXT("Failed to import audio"));
					}

					Importer->RemoveFromRoot();
				});
				RuntimeAudioImporter->ImportAudioFromBuffer(AudioData, ERuntimeAudioFormat::Mp3);
			}
			else
			{
				UE_LOG(LogTemp, Error, TEXT("TTS request failed: %s"), *ErrorStatus.ErrorMessage);
			}
		}
	)
);

स्ट्रीमिंग TTS अनुरोध

स्ट्रीमिंग TTS ऑडियो चंक्स को उत्पन्न होते ही डिलीवर करता है, जिससे आप पूरे ऑडियो के सिंथेसाइज़ होने का इंतज़ार करने के बजाय डेटा को इंक्रीमेंटली प्रोसेस कर सकते हैं। यह लंबे टेक्स्ट के लिए लेटेंसी को काफी कम कर देता है और रियल-टाइम एप्लिकेशन्स को सक्षम बनाता है।

OpenAI स्ट्रीमिंग TTS

Blueprint

C++

UPROPERTY()
UStreamingSoundWave* StreamingSoundWave;

UPROPERTY()
bool bIsPlaying = false;

UFUNCTION(BlueprintCallable)
void StartStreamingTTS()
{
    // Create a sound wave for streaming if not already created
    if (!StreamingSoundWave)
    {
        StreamingSoundWave = UStreamingSoundWave::CreateStreamingSoundWave();
        StreamingSoundWave->OnPopulateAudioStateNative.AddWeakLambda(this, [this]()
        {
            if (!bIsPlaying)
            {
                bIsPlaying = true;
                UGameplayStatics::PlaySound2D(GetWorld(), StreamingSoundWave);
            }
        });
    }

    FChatbotIntegrator_OpenAIStreamingTTSSettings TTSSettings;
    TTSSettings.Text = TEXT("Streaming synthesis output begins with a steady flow of data. This data is processed in real-time to ensure consistency. As the process continues, information is streamed without interruption. The output adapts seamlessly to changing inputs. Each piece of data is instantly integrated into the stream. Real-time processing allows for immediate adjustments. This constant flow ensures that the synthesis output is dynamic. As new data comes in, the output evolves accordingly. The system is designed to maintain a continuous output stream. This uninterrupted flow is what drives the efficiency of streaming synthesis.");
    TTSSettings.Voice = EChatbotIntegrator_OpenAIStreamingTTSVoice::ALLOY;
    
    UAIChatbotIntegratorOpenAIStreamTTS::SendStreamingTTSRequestNative(TTSSettings, FOnOpenAIStreamingTTSNative::CreateWeakLambda(this, [this](const TArray<uint8>& AudioData, bool IsFinalChunk, const FChatbotIntegratorErrorStatus& ErrorStatus)
    {
        if (!ErrorStatus.bIsError)
        {
            // Process the audio data using Runtime Audio Importer plugin
            // Example: Stream audio data into a sound wave
            UE_LOG(LogTemp, Log, TEXT("Received TTS audio data: %d bytes"), AudioData.Num());
            StreamingSoundWave->AppendAudioDataFromRAW(AudioData, ERuntimeRAWAudioFormat::Int16, 24000, 1);
        }
        else
        {
            UE_LOG(LogTemp, Error, TEXT("TTS request failed: %s"), *ErrorStatus.ErrorMessage);
        }
    }));
}

ElevenLabs Streaming TTS

Blueprint

C++

UPROPERTY()
UStreamingSoundWave* StreamingSoundWave;

UPROPERTY()
bool bIsPlaying = false;

UFUNCTION(BlueprintCallable)
void StartStreamingTTS()
{
    // Create a sound wave for streaming if not already created
    if (!StreamingSoundWave)
    {
        StreamingSoundWave = UStreamingSoundWave::CreateStreamingSoundWave();
        StreamingSoundWave->OnPopulateAudioStateNative.AddWeakLambda(this, [this]()
        {
            if (!bIsPlaying)
            {
                bIsPlaying = true;
                UGameplayStatics::PlaySound2D(GetWorld(), StreamingSoundWave);
            }
        });
    }

    FChatbotIntegrator_ElevenLabsStreamingTTSSettings TTSSettings;
    TTSSettings.Text = TEXT("Streaming synthesis output begins with a steady flow of data. This data is processed in real-time to ensure consistency. As the process continues, information is streamed without interruption. The output adapts seamlessly to changing inputs. Each piece of data is instantly integrated into the stream. Real-time processing allows for immediate adjustments. This constant flow ensures that the synthesis output is dynamic. As new data comes in, the output evolves accordingly. The system is designed to maintain a continuous output stream. This uninterrupted flow is what drives the efficiency of streaming synthesis.");
    TTSSettings.Model = EChatbotIntegrator_ElevenLabsTTSModel::ELEVEN_TURBO_V2_5;
    TTSSettings.OutputFormat = EChatbotIntegrator_ElevenLabsTTSFormat::MP3_22050_32;
    TTSSettings.VoiceID = TEXT("YOUR_VOICE_ID");
    
    UAIChatbotIntegratorElevenLabsStreamTTS::SendStreamingTTSRequestNative(GetWorld(), TTSSettings, FOnElevenLabsStreamingTTSNative::CreateWeakLambda(this, [this](const TArray<uint8>& AudioData, bool IsFinalChunk, const FChatbotIntegratorErrorStatus& ErrorStatus)
    {
        if (!ErrorStatus.bIsError)
        {
            // Process the audio data using Runtime Audio Importer plugin
            // Example: Stream audio data into a sound wave
            UE_LOG(LogTemp, Log, TEXT("Received TTS audio data: %d bytes"), AudioData.Num());
            StreamingSoundWave->AppendAudioDataFromEncoded(AudioData, ERuntimeAudioFormat::Mp3);
        }
        else
        {
            UE_LOG(LogTemp, Error, TEXT("TTS request failed: %s"), *ErrorStatus.ErrorMessage);
        }
    }));
}

त्रुटि प्रबंधन

किसी भी अनुरोध को भेजते समय, कॉलबैक में ErrorStatus की जाँच करके संभावित त्रुटियों को संभालना महत्वपूर्ण है। ErrorStatus अनुरोध के दौरान होने वाली किसी भी समस्या के बारे में जानकारी प्रदान करता है।

Blueprint

C++

// Example of error handling in a request
UAIChatbotIntegratorOpenAI::SendChatRequestNative(
    Settings, 
    FOnOpenAIChatCompletionResponseNative::CreateWeakLambda(
        this, 
        [this](const FString& Response, const FChatbotIntegratorErrorStatus& ErrorStatus)
        {
            if (ErrorStatus.bIsError)
            {
                // Handle the error
                UE_LOG(LogTemp, Error, TEXT("Chat request failed: %s"), *ErrorStatus.ErrorMessage);
            }
            else 
            {
                // Process the successful response
                UE_LOG(LogTemp, Log, TEXT("Received response: %s"), *Response);
            }
        }
    )
);

अनुरोध रद्द करना

प्लगइन आपको टेक्स्ट-टू-टेक्स्ट और TTS अनुरोधों को प्रगति में रहते हुए रद्द करने की अनुमति देता है। यह तब उपयोगी हो सकता है जब आप एक लंबे समय तक चलने वाले अनुरोध को बाधित करना चाहते हैं या वार्तालाप प्रवाह को गतिशील रूप से बदलना चाहते हैं।

Blueprint

C++

// Example of cancelling requests
UAIChatbotIntegratorOpenAI* ChatRequest = UAIChatbotIntegratorOpenAI::SendChatRequestNative(
    ChatSettings, 
    ChatResponseCallback
);

// Cancel the chat request at any time
ChatRequest->Cancel();

// TTS requests can be cancelled similarly
UAIChatbotIntegratorOpenAITTS* TTSRequest = UAIChatbotIntegratorOpenAITTS::SendTTSRequestNative(
    TTSSettings, 
    TTSResponseCallback
);

// Cancel the TTS request
TTSRequest->Cancel();

सर्वोत्तम प्रथाएँ

1. हमेशा अपने कॉलबैक में ErrorStatus की जाँच करके संभावित त्रुटियों को संभालें
2. API दर सीमाओं और लागतों का ध्यान रखें
3. लंबे या इंटरैक्टिव वार्तालापों के लिए स्ट्रीमिंग मोड का उपयोग करें
4. संसाधनों का कुशलतापूर्वक प्रबंधन करने के लिए अब आवश्यक न होने वाले अनुरोधों को रद्द करने पर विचार करें
5. कथित विलंबता को कम करने के लिए लंबे पाठों के लिए स्ट्रीमिंग TTS का उपयोग करें
6. ऑडियो प्रसंस्करण के लिए, Runtime Audio Importer प्लगइन एक सुविधाजनक समाधान प्रदान करता है, लेकिन आप अपनी परियोजना की आवश्यकताओं के आधार पर कस्टम प्रसंस्करण लागू कर सकते हैं

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

• सत्यापित करें कि आपके API क्रेडेंशियल्स सही हैं
• अपने इंटरनेट कनेक्शन की जाँच करें
• सुनिश्चित करें कि TTS सुविधाओं के साथ काम करते समय आपके द्वारा उपयोग की जाने वाली किसी भी ऑडियो प्रसंस्करण लाइब्रेरी (जैसे Runtime Audio Importer) को ठीक से स्थापित किया गया है
• TTS प्रतिक्रिया डेटा को प्रोसेस करते समय सही ऑडियो प्रारूप का उपयोग करना सुनिश्चित करें
• स्ट्रीमिंग TTS के लिए, सुनिश्चित करें कि आप ऑडियो चंक्स को सही ढंग से संभाल रहे हैं