ChatGptNet
ChatGptNet 3.3.9
ไลบรารีการรวม CHATGPT สำหรับ. NET รองรับทั้งบริการ OpenAI และ Azure OpenAI
ห้องสมุดมีให้บริการใน Nuget เพียงแค่ค้นหา chatgptnet ใน แพ็คเกจ Manager GUI หรือเรียกใช้คำสั่งต่อไปนี้ใน . NET CLI :
dotnet add package ChatGptNetลงทะเบียนบริการ chatgpt ที่แอปพลิเคชันเริ่มต้น:
builder . Services . AddChatGpt ( options =>
{
// OpenAI.
//options.UseOpenAI(apiKey: "", organization: "");
// Azure OpenAI Service.
//options.UseAzure(resourceName: "", apiKey: "", authenticationType: AzureAuthenticationType.ApiKey);
options . DefaultModel = " my-model " ;
options . DefaultEmbeddingModel = " text-embedding-ada-002 " ;
options . MessageLimit = 16 ; // Default: 10
options . MessageExpiration = TimeSpan . FromMinutes ( 5 ) ; // Default: 1 hour
options . DefaultParameters = new ChatGptParameters
{
MaxTokens = 800 ,
//MaxCompletionTokens = 800, // o1 series models support this property instead of MaxTokens
Temperature = 0.7
} ;
} ) ;ChatgptNet รองรับทั้งบริการ OpenAI และ Azure OpenAI ดังนั้นจึงจำเป็นต้องตั้งค่าการตั้งค่าการกำหนดค่าที่ถูกต้องตามผู้ให้บริการที่เลือก:
CHATGPT สามารถใช้กับโมเดลที่แตกต่างกันเพื่อให้การแชทเสร็จสมบูรณ์ทั้งในบริการ OpenAI และ Azure Openai ด้วยคุณสมบัติ defaultModel คุณสามารถระบุโมเดลเริ่มต้นที่จะใช้เว้นแต่คุณจะผ่านค่าที่ชัดเจนในวิธี Askasync หรือ Asystreamasync
แม้ว่ามันจะไม่จำเป็นอย่างยิ่งสำหรับการสนทนาการสนทนา แต่ห้องสมุดก็รองรับ API Embedding ทั้ง Openai และ Azure Openai สำหรับการแชทให้เสร็จสิ้นการฝังตัวสามารถทำได้ด้วยรุ่นที่แตกต่างกัน ด้วยคุณสมบัติ defaultembeddingModel คุณสามารถระบุโมเดลเริ่มต้นที่จะใช้เว้นแต่คุณจะผ่านค่าที่ชัดเจนในวิธี getembeddingasync
รุ่นที่มีอยู่ในปัจจุบันคือ:
พวกเขามีชื่อคงที่มีอยู่ในไฟล์ openaichatgptmodels.cs
ในบริการ Azure Openai คุณต้องปรับใช้รุ่นก่อนก่อนที่คุณจะสามารถโทรได้ เมื่อคุณปรับใช้โมเดลคุณต้องกำหนดชื่อซึ่งจะต้องตรงกับชื่อที่คุณใช้กับ ChatgptNet
หมายเหตุ บางรุ่นไม่มีให้บริการในทุกภูมิภาค คุณสามารถอ้างถึงหน้าตารางสรุปและหน้าความพร้อมใช้งานของโมเดลและภูมิภาคเพื่อตรวจสอบความพร้อมใช้งานปัจจุบัน
ChatGPT มีวัตถุประสงค์เพื่อสนับสนุนสถานการณ์การสนทนา: ผู้ใช้สามารถพูดคุยกับ ChatGPT โดยไม่ต้องระบุบริบททั้งหมดสำหรับการโต้ตอบทุกครั้ง อย่างไรก็ตามประวัติการสนทนาไม่ได้จัดการโดย Openai หรือ Azure Openai Service ดังนั้นจึงขึ้นอยู่กับเราที่จะรักษาสถานะปัจจุบัน โดยค่าเริ่มต้น ChatgptNet จัดการข้อกำหนดนี้โดยใช้หน่วยความจำที่เก็บข้อความสำหรับการสนทนาแต่ละครั้ง พฤติกรรมสามารถตั้งค่าได้โดยใช้คุณสมบัติต่อไปนี้:
หากจำเป็นต้องมีแคชที่กำหนดเองโดยใช้อินเทอร์เฟซ IchatGptCache แล้วเรียกใช้วิธีการขยาย ด้วยการใช้งาน :
public class LocalMessageCache : IChatGptCache
{
private readonly Dictionary < Guid , IEnumerable < ChatGptMessage > > localCache = new ( ) ;
public Task SetAsync ( Guid conversationId , IEnumerable < ChatGptMessage > messages , TimeSpan expiration , CancellationToken cancellationToken = default )
{
localCache [ conversationId ] = messages . ToList ( ) ;
return Task . CompletedTask ;
}
public Task < IEnumerable < ChatGptMessage > ? > GetAsync ( Guid conversationId , CancellationToken cancellationToken = default )
{
localCache . TryGetValue ( conversationId , out var messages ) ;
return Task . FromResult ( messages ) ;
}
public Task RemoveAsync ( Guid conversationId , CancellationToken cancellationToken = default )
{
localCache . Remove ( conversationId ) ;
return Task . CompletedTask ;
}
public Task < bool > ExistsAsync ( Guid conversationId , CancellationToken cancellationToken = default )
{
var exists = localCache . ContainsKey ( conversationId ) ;
return Task . FromResult ( exists ) ;
}
}
// Registers the custom cache at application startup.
builder . Services . AddChatGpt ( /* ... */ ) . WithCache < LocalMessageCache > ( ) ;นอกจากนี้เรายังสามารถตั้งค่าพารามิเตอร์ CHATGPT สำหรับการแชทให้เสร็จสิ้นเมื่อเริ่มต้น ตรวจสอบเอกสารอย่างเป็นทางการสำหรับรายการพารามิเตอร์ที่มีอยู่และความหมายของพวกเขา
การกำหนดค่าสามารถอ่านได้โดยอัตโนมัติจากการกำหนดค่าไอคอนโดยใช้ตัวอย่างส่วน chatgpt ในไฟล์ appsettings.json :
"ChatGPT": {
"Provider": "OpenAI", // Optional. Allowed values: OpenAI (default) or Azure
"ApiKey": "", // Required
//"Organization": "", // Optional, used only by OpenAI
"ResourceName": "", // Required when using Azure OpenAI Service
"ApiVersion": "2024-10-21", // Optional, used only by Azure OpenAI Service (default: 2024-10-21)
"AuthenticationType": "ApiKey", // Optional, used only by Azure OpenAI Service. Allowed values: ApiKey (default) or ActiveDirectory
"DefaultModel": "my-model",
"DefaultEmbeddingModel": "text-embedding-ada-002", // Optional, set it if you want to use embedding
"MessageLimit": 20,
"MessageExpiration": "00:30:00",
"ThrowExceptionOnError": true // Optional, default: true
//"User": "UserName",
//"DefaultParameters": {
// "Temperature": 0.8,
// "TopP": 1,
// "MaxTokens": 500,
// "MaxCompletionTokens": null, // o1 series models support this property instead of MaxTokens
// "PresencePenalty": 0,
// "FrequencyPenalty": 0,
// "ResponseFormat": { "Type": "text" }, // Allowed values for Type: text (default) or json_object
// "Seed": 42 // Optional (any integer value)
//},
//"DefaultEmbeddingParameters": {
// "Dimensions": 1536
//}
}
จากนั้นใช้วิธี overload ที่สอดคล้องกันของวิธี Che AddChatgpt :
// Adds ChatGPT service using settings from IConfiguration.
builder . Services . AddChatGpt ( builder . Configuration ) ;วิธี AddChatGPT ยังมีการโอเวอร์โหลดที่ยอมรับ IserviceProvider เป็นอาร์กิวเมนต์ มันสามารถใช้งานได้เช่นหากเราอยู่ในเว็บ API และเราจำเป็นต้องสนับสนุนสถานการณ์ที่ผู้ใช้ทุกคนมีคีย์ API ที่แตกต่างกันซึ่งสามารถเรียกดูการเข้าถึงฐานข้อมูลผ่านการฉีดพึ่งพา:
builder . Services . AddChatGpt ( ( services , options ) =>
{
var accountService = services . GetRequiredService < IAccountService > ( ) ;
// Dynamically gets the API Key from the service.
var apiKey = " ... "
options . UseOpenAI ( apiKyey ) ;
} ) ;ในสถานการณ์ที่ซับซ้อนมากขึ้นเป็นไปได้ที่จะกำหนดค่า chatgptNet โดยใช้ทั้งรหัสและการกำหนดค่าไอคอน สิ่งนี้จะมีประโยชน์หากเราต้องการตั้งค่าคุณสมบัติทั่วไป แต่ในเวลาเดียวกันเราต้องการตรรกะการกำหนดค่าบางอย่าง ตัวอย่างเช่น:
builder . Services . AddChatGpt ( ( services , options ) =>
{
// Configure common properties (message limit and expiration, default parameters, ecc.) using IConfiguration.
options . UseConfiguration ( builder . Configuration ) ;
var accountService = services . GetRequiredService < IAccountService > ( ) ;
// Dynamically gets the API Key from the service.
var apiKey = " ... "
options . UseOpenAI ( apiKyey ) ;
} ) ;chatgptnet ใช้ httpClient เพื่อเรียกการแชทเสร็จสิ้นและการฝัง APIs หากคุณต้องการปรับแต่งมันคุณสามารถใช้การโอเวอร์โหลดของเมธอด addChatGPT ที่ยอมรับการกระทำ <ihttpClientBuiler> เป็นอาร์กิวเมนต์ ตัวอย่างเช่นหากคุณต้องการเพิ่มความยืดหยุ่นให้กับไคลเอนต์ HTTP (สมมติว่านโยบายการลองใหม่) คุณสามารถใช้ Polly:
// using Microsoft.Extensions.DependencyInjection;
// Requires: Microsoft.Extensions.Http.Resilience
builder . Services . AddChatGpt ( context . Configuration ,
httpClient =>
{
// Configures retry policy on the inner HttpClient using Polly.
httpClient . AddStandardResilienceHandler ( options =>
{
options . AttemptTimeout . Timeout = TimeSpan . FromMinutes ( 1 ) ;
options . CircuitBreaker . SamplingDuration = TimeSpan . FromMinutes ( 3 ) ;
options . TotalRequestTimeout . Timeout = TimeSpan . FromMinutes ( 3 ) ;
} ) ;
} )ข้อมูลเพิ่มเติมเกี่ยวกับหัวข้อนี้มีอยู่ในเอกสารอย่างเป็นทางการ
ห้องสมุดสามารถใช้ในแอปพลิเคชัน. NET ใด ๆ ที่สร้างด้วย. NET 6.0 หรือใหม่กว่า ตัวอย่างเช่นเราสามารถสร้าง API ขั้นต่ำด้วยวิธีนี้:
app . MapPost ( " /api/chat/ask " , async ( Request request , IChatGptClient chatGptClient ) =>
{
var response = await chatGptClient . AskAsync ( request . ConversationId , request . Message ) ;
return TypedResults . Ok ( response ) ;
} )
. WithOpenApi ( ) ;
// ...
public record class Request ( Guid ConversationId , string Message ) ;หากเราต้องการเรียกคืนข้อความตอบกลับเราสามารถโทรหาวิธี getContent :
var content = response . GetContent ( ) ;หมายเหตุ หากการตอบกลับถูกกรองโดยระบบกรองเนื้อหา GetContent จะส่งคืน NULL ดังนั้นคุณควรตรวจสอบคุณสมบัติ
response.IsContentFilteredก่อนที่จะพยายามเข้าถึงเนื้อหาจริง
การใช้การกำหนดค่าเป็นไปได้ที่จะตั้งค่าพารามิเตอร์เริ่มต้นสำหรับการแชทให้เสร็จสิ้น อย่างไรก็ตามเรายังสามารถระบุพารามิเตอร์สำหรับแต่ละคำขอโดยใช้ Askasync หรือ Askstreamasync overloads ที่ยอมรับวัตถุ chatgptParameters:
var response = await chatGptClient . AskAsync ( conversationId , message , new ChatGptParameters
{
MaxTokens = 150 ,
Temperature = 0.7
} ) ;เราไม่จำเป็นต้องระบุพารามิเตอร์ทั้งหมดเฉพาะที่เราต้องการแทนที่ อีกอันจะถูกนำมาจากการกำหนดค่าเริ่มต้น
CHATGPT เป็นที่รู้จักกันว่าไม่ได้กำหนด ซึ่งหมายความว่าอินพุตเดียวกันสามารถสร้างผลลัพธ์ที่แตกต่างกัน ในการพยายามควบคุมพฤติกรรมนี้เราสามารถใช้พารามิเตอร์ อุณหภูมิ และ Topp ตัวอย่างเช่นการตั้งค่า อุณหภูมิ เป็นค่าใกล้กับ 0 ทำให้แบบจำลองกำหนดขึ้นได้มากขึ้นในขณะที่การตั้งค่าเป็นค่าใกล้กับ 1 ทำให้โมเดลสร้างสรรค์มากขึ้น อย่างไรก็ตามนี่ไม่เพียงพอที่จะได้รับเอาต์พุตเดียวกันสำหรับอินพุตเดียวกัน เพื่อแก้ไขปัญหานี้ OpenAI ได้แนะนำพารามิเตอร์ เมล็ดพันธุ์ หากระบุโมเดลควรสุ่มตัวอย่างอย่างกำหนดเช่นการร้องขอซ้ำด้วยเมล็ดพันธุ์และพารามิเตอร์เดียวกันควรส่งคืนผลลัพธ์เดียวกัน อย่างไรก็ตามการกำหนดระดับไม่ได้รับประกันในกรณีนี้และคุณควรอ้างถึงพารามิเตอร์การตอบสนองของ SystemFingerPrint เพื่อตรวจสอบการเปลี่ยนแปลงในแบ็กเอนด์ การเปลี่ยนแปลงในค่านี้หมายความว่าการกำหนดค่าแบ็กเอนด์มีการเปลี่ยนแปลงและสิ่งนี้อาจส่งผลกระทบต่อการกำหนด
เช่นเคยคุณสมบัติ เมล็ดพันธุ์ สามารถระบุได้ในการกำหนดค่าเริ่มต้นหรือใน Askasync หรือ askstreamasync overloads ที่ยอมรับ chatgptParameters
หมายเหตุ เมล็ดพันธุ์ และ SystemFingerPrint ได้รับการสนับสนุนโดยรุ่นล่าสุดเช่น GPT-4-1106-PREVIEW
หากคุณต้องการปลอมแปลงการตอบสนองในรูปแบบ JSON คุณสามารถใช้พารามิเตอร์ ResponceFormat :
var response = await chatGptClient . AskAsync ( conversationId , message , new ChatGptParameters
{
ResponseFormat = ChatGptResponseFormat . Json ,
} ) ;ด้วยวิธีนี้การตอบสนองจะเป็น JSON ที่ถูกต้องเสมอ โปรดทราบว่าจะต้องสั่งให้โมเดลสร้าง JSON ผ่านระบบหรือข้อความผู้ใช้ หากคุณไม่ทำเช่นนี้โมเดลจะส่งคืนข้อผิดพลาด
เช่นเคยคุณสมบัติ ResponceFormat สามารถระบุได้ในการกำหนดค่าเริ่มต้นหรือใน Askasync หรือ Askstreamasync overloads ที่ยอมรับ chatgptParameters
Note ResponctionFormat ได้รับการสนับสนุนโดยรุ่นล่าสุดเช่น GPT-4-1106-PREVIEW
วิธีการ Askasync และ askstreamasync (ดูด้านล่าง) ให้โอเวอร์โหลดที่ต้องใช้พารามิเตอร์ การสนทนา หากเราผ่านค่าที่ว่างเปล่าจะมีการสุ่มและส่งคืน เราสามารถส่งผ่านค่านี้ในการเรียกใช้ Askasync หรือ askstreamasync ในภายหลังเพื่อให้ห้องสมุดดึงข้อความก่อนหน้าของการสนทนาปัจจุบันโดยอัตโนมัติ (ตามการตั้งค่า MessageLimit และ MessageExpiration ) และส่งพวกเขาไปยัง API
นี่เป็นพฤติกรรมเริ่มต้นสำหรับการโต้ตอบการแชททั้งหมด หากคุณต้องการ exlude การโต้ตอบเฉพาะจากประวัติการสนทนาคุณสามารถตั้งค่าอาร์กิวเมนต์ addToconversationHistory เป็น เท็จ :
var response = await chatGptClient . AskAsync ( conversationId , message , addToConversationHistory : false ) ;ด้วยวิธีนี้ข้อความจะถูกส่งไปยัง API การแชทเสร็จสมบูรณ์ แต่มันและคำตอบที่สอดคล้องกันจาก Chatgpt จะไม่ถูกเพิ่มเข้าไปในประวัติการสนทนา
ในบางสถานการณ์มันอาจเป็นประโยชน์ในการเพิ่มการโต้ตอบแชทด้วยตนเอง (เช่นคำถามตามด้วยคำตอบ) ในประวัติการสนทนา ตัวอย่างเช่นเราอาจต้องการเพิ่มข้อความที่สร้างโดยบอท ในกรณีนี้เราสามารถใช้วิธี AddinTinCantasync :
await chatGptClient . AddInteractionAsync ( conversationId , question : " What is the weather like in Taggia? " ,
answer : " It's Always Sunny in Taggia " ) ;คำถามจะถูกเพิ่มเป็นข้อความ ผู้ใช้ และคำตอบจะถูกเพิ่มเป็นข้อความ ผู้ช่วย ในประวัติการสนทนา เช่นเคยข้อความใหม่เหล่านี้ (เกี่ยวกับตัวเลือก MessageLimit ) จะถูกนำมาใช้ในการเรียกใช้ Askasync หรือ Askstreamasync ในภายหลัง
การแชทเสร็จสิ้น API รองรับการสตรีมการตอบกลับ เมื่อใช้คุณสมบัตินี้จะส่ง Deltas ข้อความบางส่วนเช่นใน Chatgpt โทเค็นจะถูกส่งเป็นเหตุการณ์เซิร์ฟเวอร์แบบข้อมูลเท่านั้นเมื่อมีให้บริการ chatgptnet ให้การตอบสนองการสตรีมโดยใช้วิธี Askstreamasync :
// Requests a streaming response.
var responseStream = chatGptClient . AskStreamAsync ( conversationId , message ) ;
await foreach ( var response in responseStream )
{
Console . Write ( response . GetContent ( ) ) ;
await Task . Delay ( 80 ) ;
}หมายเหตุ หากการตอบกลับถูกกรองโดยระบบการกรองเนื้อหาวิธี getContent ใน foreach จะส่งคืนสตริง null ดังนั้นคุณควรตรวจสอบคุณสมบัติ
response.IsContentFilteredก่อนที่จะพยายามเข้าถึงเนื้อหาจริง
การตอบสนองการสตรีมทำงานโดยการส่งคืน IASyncenumerable ดังนั้นจึงสามารถใช้งานได้แม้ในโครงการ Web API:
app . MapGet ( " /api/chat/stream " , ( Guid ? conversationId , string message , IChatGptClient chatGptClient ) =>
{
async IAsyncEnumerable < string ? > Stream ( )
{
// Requests a streaming response.
var responseStream = chatGptClient . AskStreamAsync ( conversationId . GetValueOrDefault ( ) , message ) ;
// Uses the "AsDeltas" extension method to retrieve partial message deltas only.
await foreach ( var delta in responseStream . AsDeltas ( ) )
{
yield return delta ;
await Task . Delay ( 50 ) ;
}
}
return Stream ( ) ;
} )
. WithOpenApi ( ) ;หมายเหตุ หากการตอบกลับถูกกรองโดยระบบการกรองเนื้อหาวิธี ASDELTAS ใน foreach จะส่งคืนสตริง nulls
ห้องสมุดเข้ากันได้ 100% กับแอพพลิเคชั่น Blazor WebAssembly:
ตรวจสอบโฟลเดอร์ตัวอย่างสำหรับข้อมูลเพิ่มเติมเกี่ยวกับการใช้งานที่แตกต่างกัน
Chatgpt สนับสนุนข้อความที่มีบทบาท ระบบ ที่มีอิทธิพลต่อวิธีการที่ผู้ช่วยควรประพฤติตน ตัวอย่างเช่นเราสามารถบอกเล่าให้พูดถึงเรื่องนี้ได้:
chatgptnet จัดเตรียมคุณสมบัตินี้โดยใช้วิธี setupasync :
var conversationId await = chatGptClient . SetupAsync ( " Answer in rhyme " ) ;หากเราใช้ การสนทนา แบบเดียวกันเมื่อโทร Askasync ข้อความ ระบบ จะถูกส่งโดยอัตโนมัติพร้อมกับทุกคำขอเพื่อให้ผู้ช่วยจะรู้วิธีการประพฤติ
หมายเหตุ ข้อความ ระบบ จะไม่นับสำหรับหมายเลข จำกัด ข้อความ
ประวัติการสนทนาจะถูกลบโดยอัตโนมัติเมื่อถึงเวลาหมดอายุ (ระบุโดยคุณสมบัติ MessageExpiration ) อย่างไรก็ตามหากจำเป็นอาจเป็นไปได้ที่จะล้างประวัติทันที:
await chatGptClient . DeleteConversationAsync ( conversationId , preserveSetup : false ) ;อาร์กิวเมนต์ ServiceSetUp อนุญาตให้ตัดสินใจว่า Mantain ยังเป็นข้อความ ระบบ ที่ตั้งค่าด้วยวิธี การ setupasync (ค่าเริ่มต้น: false )
ด้วยการเรียกใช้ฟังก์ชั่นเราสามารถอธิบายฟังก์ชั่นและให้แบบจำลองเลือกที่จะส่งออกวัตถุ JSON อย่างชาญฉลาดที่มีอาร์กิวเมนต์เพื่อเรียกฟังก์ชั่นเหล่านั้น นี่เป็นวิธีใหม่ในการเชื่อมต่อความสามารถของ GPT อย่างน่าเชื่อถือกับเครื่องมือภายนอกและ APIs
chatgptnet รองรับฟังก์ชั่นการโทรอย่างเต็มที่โดยการให้ข้อมูลมากเกินไปของวิธี Askasync ที่อนุญาตให้ระบุคำจำกัดความของฟังก์ชั่น หากมีการจัดหาพารามิเตอร์นี้โมเดลจะตัดสินใจว่าจะใช้ฟังก์ชั่นหนึ่งฟังก์ชั่นเมื่อใด ตัวอย่างเช่น:
var functions = new List < ChatGptFunction >
{
new ( )
{
Name = " GetCurrentWeather " ,
Description = " Get the current weather " ,
Parameters = JsonDocument . Parse ( """
{
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "The city and/or the zip code"
},
"format": {
"type": "string",
"enum": ["celsius", "fahrenheit"],
"description": "The temperature unit to use. Infer this from the user's location."
}
},
"required": ["location", "format"]
}
""" )
} ,
new ( )
{
Name = " GetWeatherForecast " ,
Description = " Get an N-day weather forecast " ,
Parameters = JsonDocument . Parse ( """
{
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "The city and/or the zip code"
},
"format": {
"type": "string",
"enum": ["celsius", "fahrenheit"],
"description": "The temperature unit to use. Infer this from the user's location."
},
"daysNumber": {
"type": "integer",
"description": "The number of days to forecast"
}
},
"required": ["location", "format", "daysNumber"]
}
""" )
}
} ;
var toolParameters = new ChatGptToolParameters
{
FunctionCall = ChatGptToolChoices . Auto , // This is the default if functions are present.
Functions = functions
} ;
var response = await chatGptClient . AskAsync ( " What is the weather like in Taggia? " , toolParameters ) ;เราสามารถผ่านจำนวนฟังก์ชั่นโดยพลการแต่ละคนมีชื่อคำอธิบายและสคีมา JSON ที่อธิบายถึงพารามิเตอร์ฟังก์ชันตามการอ้างอิงสคีมา JSON ภายใต้ประทุนฟังก์ชั่นจะถูกฉีดเข้าไปในข้อความระบบในไวยากรณ์โมเดลได้รับการฝึกอบรม ซึ่งหมายความว่าฟังก์ชั่นจะนับรวมกับขีด จำกัด บริบทของโมเดลและถูกเรียกเก็บเงินเป็นโทเค็นอินพุต
วัตถุตอบสนองที่ส่งคืนโดยวิธี Askasync ให้คุณสมบัติเพื่อตรวจสอบว่าโมเดลได้เลือกการเรียกใช้ฟังก์ชัน:
if ( response . ContainsFunctionCalls ( ) )
{
Console . WriteLine ( " I have identified a function to call: " ) ;
var functionCall = response . GetFunctionCall ( ) ! ;
Console . WriteLine ( functionCall . Name ) ;
Console . WriteLine ( functionCall . Arguments ) ;
}รหัสนี้จะพิมพ์บางอย่างเช่นนี้:
I have identified a function to call:
GetCurrentWeather
{
"location": "Taggia",
"format": "celsius"
}
โปรดทราบว่า API จะไม่เรียกใช้การเรียกใช้ฟังก์ชันใด ๆ มันขึ้นอยู่กับนักพัฒนาซอฟต์แวร์ที่เรียกใช้การเรียกใช้ฟังก์ชันโดยใช้เอาต์พุตโมเดล
หลังจากการดำเนินการจริงเราจำเป็นต้องโทรหาวิธี AddToolResponseAsync บน chatgptClient เพื่อเพิ่มการตอบสนองต่อประวัติการสนทนาเช่นเดียวกับข้อความมาตรฐานเพื่อให้มันถูกใช้โดยอัตโนมัติสำหรับการแชท
// Calls the remote function API.
var functionResponse = await GetWeatherAsync ( functionCall . Arguments ) ;
await chatGptClient . AddToolResponseAsync ( conversationId , functionCall , functionResponse ) ;รุ่นใหม่เช่น GPT-4-Turbo รองรับวิธีการทั่วไปในการใช้งาน การเรียกใช้เครื่องมือ เมื่อคุณส่งคำขอคุณสามารถระบุรายการเครื่องมือที่รุ่นอาจเรียก ปัจจุบันมีเพียงฟังก์ชั่นเท่านั้นที่ได้รับการสนับสนุน แต่ในการเปิดตัวเครื่องมือประเภทอื่น ๆ ในอนาคตจะพร้อมใช้งาน
ในการใช้การเรียกใช้เครื่องมือแทนการเรียกใช้ฟังก์ชันโดยตรงคุณต้องตั้งค่าคุณสมบัติ เครื่องมือ และ เครื่องมือ ในวัตถุ chatgpttoolparameters (แทนที่จะเป็น ฟังก์ชั่น และ ฟังก์ชั่น เช่นเดียวกับในตัวอย่างก่อนหน้า):
var toolParameters = new ChatGptToolParameters
{
ToolChoice = ChatGptToolChoices . Auto , // This is the default if functions are present.
Tools = functions . ToTools ( )
} ;วิธีการขยาย totools ใช้เพื่อแปลงรายการของ chatgptfunction เป็นรายการเครื่องมือ
หากคุณใช้วิธีการใหม่นี้แน่นอนว่าคุณยังต้องตรวจสอบว่าโมเดลได้เลือกการโทรเครื่องมือโดยใช้วิธีการเดียวกันที่แสดงก่อนหน้านี้หรือไม่ จากนั้นหลังจากการดำเนินการจริงของฟังก์ชั่นคุณต้องเรียกใช้วิธี AddToolResponseAsync แต่ในกรณีนี้คุณต้องระบุเครื่องมือ (ไม่ใช่ฟังก์ชั่น) ที่การตอบกลับหมายถึง:
var tool = response . GetToolCalls ( ) ! . First ( ) ;
var functionCall = response . GetFunctionCall ( ) ! ;
// Calls the remote function API.
var functionResponse = await GetWeatherAsync ( functionCall . Arguments ) ;
await chatGptClient . AddToolResponseAsync ( conversationId , tool , functionResponse ) ;ในที่สุดคุณจะต้องส่งข้อความต้นฉบับไปยัง API การแชทเสร็จสมบูรณ์เพื่อให้โมเดลสามารถดำเนินการสนทนาต่อโดยคำนึงถึงการตอบสนองการเรียกใช้ฟังก์ชัน ตรวจสอบตัวอย่างฟังก์ชั่นการเรียกใช้สำหรับการใช้งานที่สมบูรณ์ของเวิร์กโฟลว์นี้
เมื่อใช้บริการ Azure Openai เราจะได้รับการกรองเนื้อหาโดยอัตโนมัติฟรี สำหรับรายละเอียดเกี่ยวกับวิธีการทำงานให้ตรวจสอบเอกสาร ข้อมูลนี้จะถูกส่งคืนสำหรับทุกสถานการณ์เมื่อใช้ API เวอร์ชัน 2023-06-01-preview หรือใหม่กว่า chatgptnet รองรับโมเดลวัตถุนี้อย่างเต็มที่โดยให้คุณสมบัติที่เกี่ยวข้องในคลาส chatgptresponse และ chatgptchoice
EMBEDDINGS อนุญาตให้แปลงข้อความเป็นพื้นที่เวกเตอร์ สิ่งนี้มีประโยชน์ในการเปรียบเทียบความคล้ายคลึงกันของสองประโยคเช่น chatgptnet รองรับคุณสมบัตินี้อย่างเต็มที่โดยการจัดหาวิธี getembeddingasync :
var response = await chatGptClient . GenerateEmbeddingAsync ( message ) ;
var embeddings = response . GetEmbedding ( ) ;รหัสนี้จะให้อาร์เรย์ลอยที่มี embeddings ทั้งหมดสำหรับข้อความที่ระบุ ความยาวของอาร์เรย์ขึ้นอยู่กับแบบจำลองที่ใช้:
| แบบอย่าง | มิติเอาต์พุต |
|---|---|
| Text-Embedding-ADA-002 | ค.ศ. 1536 |
| Text-Embedding-3-small | ค.ศ. 1536 |
| Text-Embedding-3 ใหญ่ | 3072 |
รุ่นใหม่เช่น การฝังตัวข้อความ -3-small และ embedding-3 ขนาดใหญ่ ช่วยให้นักพัฒนาสามารถแลกเปลี่ยนประสิทธิภาพและค่าใช้จ่ายในการใช้การฝังตัว โดยเฉพาะอย่างยิ่งนักพัฒนาสามารถทำให้การฝังตัวสั้นลงโดยไม่ต้องฝังตัวสูญเสียคุณสมบัติการเป็นตัวแทนของแนวคิด
สำหรับ CHATGPT การตั้งค่านี้สามารถทำได้หลายวิธี:
builder . Services . AddChatGpt ( options =>
{
// ...
options . DefaultEmbeddingParameters = new EmbeddingParameters
{
Dimensions = 256
} ;
} ) ; "ChatGPT": {
"DefaultEmbeddingParameters": {
"Dimensions": 256
}
}
จากนั้นหากคุณต้องการเปลี่ยนมิติสำหรับคำขอเฉพาะคุณสามารถระบุอาร์กิวเมนต์ EmbeddingParameters ในการเรียกใช้ GetembeddingAsync :
var response = await chatGptClient . GenerateEmbeddingAsync ( request . Message , new EmbeddingParameters
{
Dimensions = 512
} ) ;
var embeddings = response . GetEmbedding ( ) ; // The length of the array is 512หากคุณต้องการคำนวณความคล้ายคลึงกันของโคไซน์ระหว่างการฝังสองครั้งคุณสามารถใช้วิธีการ EmbeddingUtility.cosinesimilarity
เอกสารทางเทคนิคแบบเต็มมีอยู่ที่นี่
โครงการมีการพัฒนาอย่างต่อเนื่อง ยินดีต้อนรับการมีส่วนร่วม อย่าลังเลที่จะยื่นปัญหาและดึงคำขอบน repo และเราจะจัดการกับพวกเขาเท่าที่จะทำได้
คำเตือน อย่าลืมทำงานกับสาขา พัฒนา อย่าใช้สาขา หลัก โดยตรง สร้างคำขอดึงที่กำหนดเป้าหมาย การพัฒนา
