chat_gpt_sdk Download - chat_gpt_sdk -Quellcode herunterladen

Chatgpt -Anwendung mit Flutter

Chatgpt ist ein Chat-Bot, der im November 2022 von OpenAI gestartet wurde. Es basiert auf OpenAs GPT-3,5-Familie großer Sprachmodelle.

Inoffiziell

"Community-gepflegt" Bibliothek.

OpenAI Mächtiger Bibliothek Support GPT-4

Merkmale

Paket installieren

chat_gpt_sdk : 3.1 . 3

Erstellen Sie eine OpenAI -Instanz

Parameter
- Token
  - Ihre geheimen API -Schlüssel sind unten aufgeführt. Bitte beachten Sie, dass wir Ihre geheimen API -Schlüssel nicht wieder anzeigen, nachdem Sie sie generiert haben.
  - Teilen Sie Ihren API-Schlüssel nicht mit anderen und legen Sie sie im Browser oder im anderen clientseitigen Code nicht frei. Um die Sicherheit Ihres Kontos zu schützen, kann OpenAI auch automatisch jeden API -Schlüssel drehen, den wir gefunden haben, ist öffentlich durchgesickert.
  - https://beta.openai.com/account/api-keys
Orgid
- Kennung für diese Organisation, die manchmal in API -Anfragen verwendet wird
- https://beta.openai.com/account/org-settings

 final openAI = OpenAI .instance. build (token : token,baseOption : HttpSetup (receiveTimeout : const Duration (seconds : 5 )),enableLog : true );

Ändern Sie Zugangstoken

openAI. setToken ( 'new-access-token' );
///get token
openAI.token;

Vollständiger Text

Text vollständiger API
- Methode übersetzen
  - translateEntothai
  - Translatethaitoeng
  - Übersetzter
- Modell
  - ktranslatemodelv3
  - ktranslatemodelv2
  - kcodetranslatemodelv2
    - Übersetzen Sie die natürliche Sprache in SQL -Abfragen.
    - Erstellen Sie Code, um die Stripe -API mit natürlicher Sprache aufzurufen.
    - Finden Sie die zeitliche Komplexität einer Funktion.
- https://beta.openai.com/examples
Komplett mit Funktion

  void _translateEngToThai () async {
  final request = CompleteText (
          prompt : translateEngToThai (word : _txtWord.text. toString ()),
          maxToken : 200 ,
          model : TextDavinci3Model ());

  final response = await openAI. onCompletion (request : request);
  
  ///cancel request
  openAI. cancelAIGenerate ();
  print (response);
}

Komplett mit FutureBuilder

 Future < CTResponse ?> ? _translateFuture;

_translateFuture = openAI. onCompletion (request : request);

///ui code
FutureBuilder < CTResponse ?>(
 future : _translateFuture,
 builder : (context, snapshot) {
   final data = snapshot.data;
   if (snapshot.connectionState == ConnectionState .done) return something 
   if (snapshot.connectionState == ConnectionState .waiting) return something
   return something
})

GPT 3 mit SSE

 void completeWithSSE () {
  final request = CompleteText (
          prompt : "Hello world" , maxTokens : 200 , model : TextDavinci3Model ());
  openAI. onCompletionSSE (request : request). listen ((it) {
    debugPrint (it.choices.last.text);
  });
}

Chat vollständig (GPT-4 und GPT-3.5)

Chat vollständig

  void chatComplete () async {
    final request = ChatCompleteText (messages : [
      Map . of ({ "role" : "user" , "content" : 'Hello!' })
    ], maxToken : 200 , model : Gpt4ChatModel ());

    final response = await openAI. onChatCompletion (request : request);
    for ( var element in response ! .choices) {
      print ( "data -> ${ element . message ?. content }" );
    }
  }

GPT 4 mit SSE

 void chatCompleteWithSSE () {
  final request = ChatCompleteText (messages : [
    Map . of ({ "role" : "user" , "content" : 'Hello!' })
  ], maxToken : 200 , model : Gpt4ChatModel ());

  openAI. onChatCompletionSSE (request : request). listen ((it) {
    debugPrint (it.choices.last.message ? .content);
  });
}

Support SSE (Server senden Ereignis)
- GPT-3,5 Turbo

 void chatCompleteWithSSE () {
  final request = ChatCompleteText (messages : [
    Map . of ({ "role" : "user" , "content" : 'Hello!' })
  ], maxToken : 200 , model : GptTurboChatModel ());

  openAI. onChatCompletionSSE (request : request). listen ((it) {
    debugPrint (it.choices.last.message ? .content);
  });
}

Chat vollständig

  void chatComplete () async {
    final request = ChatCompleteText (messages : [
      Map . of ({ "role" : "user" , "content" : 'Hello!' })
    ], maxToken : 200 , model : Gpt41106PreviewChatModel ());

    final response = await openAI. onChatCompletion (request : request);
    for ( var element in response ! .choices) {
      print ( "data -> ${ element . message ?. content }" );
    }
  }

CHAT -Komplettfunktion aufrufen

  void gptFunctionCalling () async {
    final request = ChatCompleteText (
      messages : [
        Messages (
                role : Role .user,
                content : "What is the weather like in Boston?" ,
                name : "get_current_weather" ),
      ],
      maxToken : 200 ,
      model : Gpt41106PreviewChatModel (),
      tools : [
        {
          "type" : "function" ,
          "function" : {
            "name" : "get_current_weather" ,
            "description" : "Get the current weather in a given location" ,
            "parameters" : {
              "type" : "object" ,
              "properties" : {
                "location" : {
                  "type" : "string" ,
                  "description" : "The city and state, e.g. San Francisco, CA"
                },
                "unit" : {
                  "type" : "string" ,
                  "enum" : [ "celsius" , "fahrenheit" ]
                }
              },
              "required" : [ "location" ]
            }
          }
        }
      ],
      toolChoice : 'auto' ,
    );

    ChatCTResponse ? response = await openAI. onChatCompletion (request : request);
}

CHAT Komplette Bildeingabe

  void imageInput () async {
  final request = ChatCompleteText (
    messages : [
      {
        "role" : "user" ,
        "content" : [
          { "type" : "text" , "text" : "What’s in this image?" },
          {
            "type" : "image_url" ,
            "image_url" : { "url" : "image-url" }
          }
        ]
      }
    ],
    maxToken : 200 ,
    model : Gpt4VisionPreviewChatModel (),
  );

  ChatCTResponse ? response = await openAI. onChatCompletion (request : request);
  debugPrint ( "$ response " );
}

Assistenten

Assistent erstellen

  void createAssistant () async {
  final assistant = Assistant (
    model : Gpt4AModel (),
    name : 'Math Tutor' ,
    instructions :
    'You are a personal math tutor. When asked a question, write and run Python code to answer the question.' ,
    tools : [
      {
        "type" : "code_interpreter" ,
      }
    ],
  );
  await openAI.assistant. create (assistant : assistant);
}

Assistenzdatei erstellen

 void createAssistantFile () async {
  await openAI.assistant. createFile (assistantId : '' ,fileId : '' ,);
}

Assistenten auflisten

  void listAssistant () async {
  final assistants = await openAI.assistant. list ();
  assistants. map ((e) => e. toJson ()). forEach (print);
}

Listen Sie Assistentendateien auf

  void listAssistantFile () async {
  final assistants = await openAI.assistant. listFile (assistantId : '' );
  assistants.data. map ((e) => e. toJson ()). forEach (print);
}

Assistent abrufen

  void retrieveAssistant () async {
  final assistants = await openAI.assistant. retrieves (assistantId : '' );
}

Assistenzdatei abrufen

  void retrieveAssistantFiles () async {
  final assistants = await openAI.assistant. retrievesFile (assistantId : '' ,fileId : '' );
}

Assistent ändern

  void modifyAssistant () async {
  final assistant = Assistant (
    model : Gpt4AModel (),
    instructions :
    'You are an HR bot, and you have access to files to answer employee questions about company policies. Always response with info from either of the files.' ,
    tools : [
      {
        "type" : "retrieval" ,
      }
    ],
    fileIds : [
      "file-abc123" ,
      "file-abc456" ,
    ],
  );
  await openAI.assistant. modifies (assistantId : '' , assistant : assistant);
}

Assistent löschen

  void deleteAssistant () async {
  await openAI.assistant. delete (assistantId : '' );
}

Assistenzdatei löschen

  void deleteAssistantFile () async {
  await openAI.assistant. deleteFile (assistantId : '' ,fileId : '' );
}

Mit Assistant V2

openAI.assistant.v2;

Themen

Threads erstellen

 ///empty body
  void createThreads () async {
  await openAI.threads. createThread (request : ThreadRequest ());
}

///with message
void createThreads () async {
  final request = ThreadRequest (messages : [
    {
      "role" : "user" ,
      "content" : "Hello, what is AI?" ,
      "file_ids" : [ "file-abc123" ]
    },
    {
      "role" : "user" ,
      "content" : "How does AI work? Explain it in simple terms."
    },
  ]);

  await openAI.threads. createThread (request : request);
}

Faden abrufen

 void retrieveThread () async {
  final mThread = await openAI.threads. retrieveThread (threadId : 'threadId' );
}

Thread ändern

  void modifyThread () async {
  await openAI.threads. modifyThread (threadId : 'threadId' , metadata : {
    "metadata" : {
      "modified" : "true" ,
      "user" : "abc123" ,
    },
  });
}

Thread löschen

  void deleteThread () async {
  await openAI.threads. deleteThread (threadId : 'threadId' );
}

Verwenden von Thread V2

openAI.threads.v2;

Nachrichten

Nachricht erstellen

 void createMessage () async {
  final request = CreateMessage (
    role : 'user' ,
    content : 'How does AI work? Explain it in simple terms.' ,
  );
  await openAI.threads.messages. createMessage (
    threadId : 'threadId' ,
    request : request,
  );
}

Meldungen auflisten

  void listMessage () async {
  final mMessages = await openAI.threads.messages. listMessage (threadId : 'threadId' );
}

Listen Sie Nachrichtendateien auf

  void listMessageFile () async {
  final mMessagesFile = await openAI.threads.messages. listMessageFile (
    threadId : 'threadId' ,
    messageId : '' ,
  );
}

Nachricht abrufen

  void retrieveMessage () async {
  final mMessage = await openAI.threads.messages. retrieveMessage (
    threadId : 'threadId' ,
    messageId : '' ,
  );
}

Meldungsdatei abrufen

 void retrieveMessageFile () async {
  final mMessageFile = await openAI.threads.messages. retrieveMessageFile (
    threadId : 'threadId' ,
    messageId : '' ,
    fileId : '' ,
  );
}

Meldung ändern

  void modifyMessage () async {
  await openAI.threads.messages. modifyMessage (
    threadId : 'threadId' ,
    messageId : 'messageId' ,
    metadata : {
      "metadata" : { "modified" : "true" , "user" : "abc123" },
    },
  );
}

Verwenden von Nachricht V2

openAI.threads.v2.messages;

Läuft

Run erstellen

 void createRun () async {
    final request = CreateRun (assistantId : 'assistantId' );
    await openAI.threads.runs. createRun (threadId : 'threadId' , request : request);
  }

Thread erstellen und ausführen

  void createThreadAndRun () async {
    final request = CreateThreadAndRun (assistantId : 'assistantId' , thread : {
      "messages" : [
        { "role" : "user" , "content" : "Explain deep learning to a 5 year old." }
      ],
    });
    await openAI.threads.runs. createThreadAndRun (request : request);
  }

Liste läuft

 void listRuns () async {
   final mRuns = await openAI.threads.runs. listRuns (threadId : 'threadId' );
  }

Listen Sie die Ausführungsschritte auf

 void listRunSteps () async {
   final mRunSteps = await openAI.threads.runs. listRunSteps (threadId : 'threadId' ,runId : '' ,);
  }

Run abrufen

 void retrieveRun () async {
   final mRun = await openAI.threads.runs. retrieveRun (threadId : 'threadId' ,runId : '' ,);
  }

Run -Schritt abrufen

 void retrieveRunStep () async {
   final mRun = await openAI.threads.runs. retrieveRunStep (threadId : 'threadId' ,runId : '' ,stepId : '' );
  }

Ausführen ändern

 void modifyRun () async {
    await openAI.threads.runs. modifyRun (
      threadId : 'threadId' ,
      runId : '' ,
      metadata : {
        "metadata" : { "user_id" : "user_abc123" },
      },
    );
  }

Senden Sie Toolausgänge zum Ausführen

  void submitToolOutputsToRun () async {
    await openAI.threads.runs. submitToolOutputsToRun (
      threadId : 'threadId' ,
      runId : '' ,
      toolOutputs : [
        {
          "tool_call_id" : "call_abc123" ,
          "output" : "28C" ,
        },
      ],
    );
  }

Einen Lauf stornieren

  void cancelRun () async {
    await openAI.threads.runs. cancelRun (
      threadId : 'threadId' ,
      runId : '' ,
    );
  }

Fehlergriff

 ///using catchError
 openAI. onCompletion (request : request)
    . catchError ((err){
      if (err is OpenAIAuthError ){
        print ( 'OpenAIAuthError error ${ err . data ?. error ?. toMap ()}' );
      }
      if (err is OpenAIRateLimitError ){
        print ( 'OpenAIRateLimitError error ${ err . data ?. error ?. toMap ()}' );
      }
      if (err is OpenAIServerError ){
        print ( 'OpenAIServerError error ${ err . data ?. error ?. toMap ()}' );
      }
      });

///using try catch
 try {
   await openAI. onCompletion (request : request);
 } on OpenAIRateLimitError catch (err) {
   print ( 'catch error ->${ err . data ?. error ?. toMap ()}' );
 }

///with stream
 openAI
        . onCompletionSSE (request : request)
        . transform ( StreamTransformer . fromHandlers (
          handleError : (error, stackTrace, sink) {
              if (error is OpenAIRateLimitError ) {
              print ( 'OpenAIRateLimitError error ->${ error . data ?. message }' );
              }}))
        . listen ((event) {
          print ( "success" );
        });

Fragen und a

Beispiel Q & A.
- Beantworten Sie Fragen basierend auf vorhandenem Wissen.

 final request = CompleteText (prompt : 'What is human life expectancy in the United States?' ),
                model : TextDavinci3Model (), maxTokens : 200 );

 final response = await openAI. onCompletion (request : request);

Anfrage

 Q : What is human life expectancy in the United States ?

Antwort

 A : Human life expectancy in the United States is 78 years.

Bild mit Eingabeaufforderung erstellen

Bild erzeugen
- prompt
  - Eine Textbeschreibung des gewünschten Bildes (en). Die maximale Länge beträgt 1000 Zeichen.
- N
  - Die Anzahl der zu generierten Bilder. Muss zwischen 1 und 10 sein.
- Größe
  - Die Größe der erzeugten Bilder. Muss einer von 256x256, 512x512 oder 1024x1024 sein.
- Antwort_Format
  - Das Format, in dem die erzeugten Bilder zurückgegeben werden. Muss einer von URL oder B64_JSON sein.
- Benutzer
  - Eine eindeutige Kennung, die Ihren Endbenutzer repräsentiert, das dazu beitragen kann, Missbrauch zu überwachen und zu erkennen.
Mit Funktion erzeugen

  void _generateImage () {
  const prompt = "cat eating snake blue red." ;

  final request = GenerateImage ( model : DallE2 (),prompt, 1 ,size : ImageSize .size256,
          responseFormat : Format .url);
  final response = openAI. generateImage (request);
  print ( "img url :${ response . data ?. last ?. url }" );
}

Bearbeiten

Eingabeaufforderung bearbeiten

 void editPrompt () async {
    final response = await openAI.editor. prompt ( EditRequest (
        model : CodeEditModel (),
        input : 'What day of the wek is it?' ,
        instruction : 'Fix the spelling mistakes' ));

    print (response.choices.last.text);
  }

Bild bearbeiten

 void editImage () async {
  final response = await openAI.editor. editImage ( EditImageRequest (
          image : FileInfo ( "${ image ?. path }" , '${ image ?. name }' ),
          mask : FileInfo ( 'file path' , 'file name' ),
          size : ImageSize .size1024,
          prompt : 'King Snake' ),
          model : DallE3 (),);

  print (response.data ? .last ? .url);
}

Variationen

  void variation () async {
  final request =
  Variation (model : DallE2 (),image : FileInfo ( '${ image ?. path }' , '${ image ?. name }' ));
  final response = await openAI.editor. variation (request);

  print (response.data ? .last ? .url);
}

Abbrechen generieren

Stoppen Sie die Eingabeaufforderung

 _openAI
        . onChatCompletionSSE (request : request, onCancel : onCancel);

///CancelData
CancelData ? mCancel;
void onCancel ( CancelData cancelData) {
  mCancel = cancelData;
}

mCancel ? .cancelToken. cancel ( "canceled " );

Hören Sie auf zu bearbeiten
- Bild
- prompt

openAI.edit. editImage (request,onCancel : onCancel);

///CancelData
CancelData ? mCancel;
void onCancel ( CancelData cancelData) {
  mCancel = cancelData;
}

mCancel ? .cancelToken. cancel ( "canceled edit image" );

Hör auf einzubetten

openAI.embed. embedding (request,onCancel : onCancel);

///CancelData
CancelData ? mCancel;
void onCancel ( CancelData cancelData) {
  mCancel = cancelData;
}

mCancel ? .cancelToken. cancel ( "canceled embedding" );

Audio stoppen
- übersetzen
- Transkript

openAI.audio. transcribes (request,onCancel : onCancel);

///CancelData
CancelData ? mCancel;
void onCancel ( CancelData cancelData) {
  mCancel = cancelData;
}

mCancel ? .cancelToken. cancel ( "canceled audio transcribes" );

Datei stoppen
- Datei hochladen
- Datei abrufen
- Datei löschen

openAI.file. uploadFile (request,onCancel : onCancel);

///CancelData
CancelData ? mCancel;
void onCancel ( CancelData cancelData) {
  mCancel = cancelData;
}

mCancel ? .cancelToken. cancel ( "canceled uploadFile" );

Datei

Datei abrufen

 void getFile () async {
  final response = await openAI.file. get ();
  print (response.data);
}

Datei hochladen

 void uploadFile () async {
  final request = UploadFile (file : FileInfo ( 'file-path' , 'file-name' ),purpose : 'fine-tune' );
  final response = await openAI.file. uploadFile (request);
  print (response);
}

Datei löschen

  void delete () async {
  final response = await openAI.file. delete ( "file-Id" );
  print (response);
}

Datei abrufen

  void retrieve () async {
  final response = await openAI.file. retrieve ( "file-Id" );
  print (response);
}

Inhaltsdatei abrufen

  void retrieveContent () async {
  final response = await openAI.file. retrieveContent ( "file-Id" );
  print (response);
}

Audio

Audio übersetzen

 void audioTranslate () async {
  final mAudio = File ( 'mp3-path' );
  final request =
  AudioRequest (file : FileInfo (mAudio.path, 'name' ), prompt : '...' );

  final response = await openAI.audio. translate (request);
}

Audio -Transkribe

 void audioTranscribe () async {
  final mAudio = File ( 'mp3-path' );
  final request =
  AudioRequest (file : FileInfo (mAudio.path, 'name' ), prompt : '...' );

  final response = await openAI.audio. transcribes (request);
}

Sprache erstellen

  void createSpeech () async {
  final request = SpeechRequest (
          model : 'tts-1' , input : 'The quick brown fox jumped over the lazy dog.' );

  final List < int > response = await openAI.audio
          . createSpeech (request : request);
}

Einbettung

Einbettung

 void embedding () async {
  final request = EmbedRequest (
          model : TextSearchAdaDoc001EmbedModel (),
          input : 'The food was delicious and the waiter' );

  final response = await openAI.embed. embedding (request);

  print (response.data.last.embedding);
}

Feine Melodie

Erstellen Sie eine gute Melodie

 void createTineTune () async {
  final request = CreateFineTuneJob (trainingFile : 'The ID of an uploaded file' );
  final response = await openAI.fineTune. createFineTuneJob (request);
}

Fine Tune List

 void tineTuneList () async {
    final response = await openAI.fineTune. listFineTuneJob ();
  }

Fine Tune List Stream

 void tineTuneListStream () {
    openAI.fineTune. listFineTuneJobStream ( 'fineTuneId' ). listen ((it) {
      ///handled data
    });
  }

Feine Melodie Get Id ID

 void tineTuneById () async {
    final response = await openAI.fineTune. retrieveFineTuneJob ( 'fineTuneId' );
  }

Fine Melodie abbrechen

  void tineTuneCancel () async {
    final response = await openAI.fineTune. cancel ( 'fineTuneId' );
  }

Feine Melodie löschen

 void deleteTineTune () async {
    final response = await openAI.fineTune. delete ( 'model' );
  }

Moderationen

Mäßigung erstellen

  void createModeration () async {
  final response = await openAI.moderation
          . create (input : 'input' , model : TextLastModerationModel ());
}

Modell & Motor

Modellliste
- Listen und beschreiben Sie die verschiedenen in der API verfügbaren Modelle. Sie können sich auf die Modelsdokumentation beziehen, um zu verstehen, welche Modelle verfügbar sind und welche Unterschiede zwischen ihnen sind.
- https://beta.openai.com/docs/api-reference/models

 final models = await openAI. listModel ();

Motorliste
- Listet die aktuell verfügbaren (nicht-finetuned) Modelle auf und liefert grundlegende Informationen zu jedem einzelnen wie dem Eigentümer und der Verfügbarkeit.
- https://beta.openai.com/docs/api-reference/engines

 final engines = await openAI. listEngine ();

chat_gpt_sdk

Chatgpt -Anwendung mit Flutter

Inoffiziell

OpenAI Mächtiger Bibliothek Support GPT-4

Merkmale

Paket installieren

Erstellen Sie eine OpenAI -Instanz

Ändern Sie Zugangstoken

Vollständiger Text

Komplett mit Funktion

GPT 3 mit SSE

Chat vollständig (GPT-4 und GPT-3.5)

Chat vollständig

GPT 4 mit SSE

CHAT -Komplettfunktion aufrufen

CHAT Komplette Bildeingabe

Assistenten

Assistent erstellen

Assistenzdatei erstellen

Assistenten auflisten

Listen Sie Assistentendateien auf

Assistent abrufen

Assistenzdatei abrufen

Assistent ändern

Assistent löschen

Assistenzdatei löschen

Mit Assistant V2

Themen

Threads erstellen

Faden abrufen

Thread ändern

Thread löschen

Verwenden von Thread V2

Nachrichten

Nachricht erstellen

Meldungen auflisten

Listen Sie Nachrichtendateien auf

Nachricht abrufen

Meldungsdatei abrufen

Meldung ändern

Verwenden von Nachricht V2

Läuft

Run erstellen

Thread erstellen und ausführen

Liste läuft

Listen Sie die Ausführungsschritte auf

Run abrufen

Run -Schritt abrufen

Ausführen ändern

Senden Sie Toolausgänge zum Ausführen

Einen Lauf stornieren

Fehlergriff

Fragen und a

Bild mit Eingabeaufforderung erstellen

Mit Funktion erzeugen

Bearbeiten

Eingabeaufforderung bearbeiten

Bild bearbeiten

Variationen

Abbrechen generieren

Stoppen Sie die Eingabeaufforderung

Hören Sie auf zu bearbeiten

Hör auf einzubetten

Datei

Datei abrufen

Datei hochladen

Datei löschen

Datei abrufen

Inhaltsdatei abrufen

Audio

Audio übersetzen

Audio -Transkribe

Sprache erstellen

Einbettung

Feine Melodie

Erstellen Sie eine gute Melodie

Fine Tune List

Fine Tune List Stream

Feine Melodie Get Id ID

Fine Melodie abbrechen