Textchat

Das Foundation-Model für PaLM 2 for Chat (chat-bison) ist ein großes Sprachmodell (LLM, Large Language Model), das in Sachen Spracherkennung, Sprachgenerierung und Unterhaltungen hervorragendes leistet. Dieses Chat-Modell wurde darauf optimiert, natürliche Unterhaltungen zu führen. Es eignet sich ideal für Textaufgaben zu Code, die gegenseitige Kommunikation erfordern.

Verwenden Sie für Textaufgaben, die mit einer einzigen API-Antwort ausgeführt werden können (ohne kontinuierliche Unterhaltung), das Textmodell.

Weitere Informationen zu diesem Modell finden Sie in der Console auf der Modellkarte "PLM 2 for Chat" im Model Garden.
Zum Model Garden

Anwendungsfälle

Kundenservice: Weisen Sie das Modell an, als Kundenservicemitarbeiter zu antworten, der nur über das Produkt Ihres Unternehmens spricht.
Technischer Support: Weisen Sie das Modell an, mit Kunden als Callcenter-Agent zu kommunizieren, wobei spezifische Vorgaben zu kommunizierbaren und nicht auszudrückenden Inhalten bestehen.
Identitäten und Charaktere: Weisen Sie das Modell an, im Stil einer bestimmten Person zu antworten ("... im Stil von Shakespeare").
Website-Companion: Erstellen Sie einen Unterhaltungsassistenten für Shopping, Reisen und andere Anwendungsfälle.

Weitere Informationen finden Sie unter Chat-Prompts erstellen.

HTTP-Anfrage

POST https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/publishers/google/models/chat-bison:predict

Weitere Informationen finden Sie im Artikel zur predict-Methode.

Modellversionen

Wenn Sie die neueste Modellversion verwenden möchten, geben Sie den Modellnamen ohne Versionsnummer an, z. B. chat-bison.

Wenn Sie eine stabile Modellversion verwenden möchten, geben Sie die Modellversionsnummer an, z. B. chat-bison@002. Stabile Versionen sind ab dem Releasedatum der nachfolgenden stabilen Version noch sechs Monate verfügbar.

Die folgende Tabelle enthält die verfügbaren stabilen Modellversionen:

Chat-bison-Modell	Veröffentlicht	Einstellungsdatum
chat-bison@002	6. Dezember 2023	9. Oktober 2024
chat-bison@001	10. Juli 2023	6. Juli 2024

Weitere Informationen finden Sie unter Modellversionen und Lebenszyklus.

Anfragetext

{
  "instances": [
    {
      "context":  string,
      "examples": [
        {
          "input": { "content": string },
          "output": { "content": string }
        }
      ],
      "messages": [
        {
          "author": string,
          "content": string,
        }
      ],
    }
  ],
  "parameters": {
    "temperature": number,
    "maxOutputTokens": integer,
    "topP": number,
    "topK": integer,
    "groundingConfig": string,
    "stopSequences": [ string ],
    "candidateCount": integer
    "logprobs": integer,
    "presencePenalty": float,
    "frequencyPenalty": float,
    "seed": integer
  }
}

Bei Chat-API-Aufrufen bilden context, examples und messages zusammen den Prompt. Die folgende Tabelle zeigt die Parameter, die Sie für die Vertex AI PaLM API für Text konfigurieren müssen:

Parameter	Beschreibung	Zulässige Werte
`context` (optional)	Der Kontext bestimmt, wie das Modell während der Unterhaltung reagiert. Beispielsweise können Sie mit dem Kontext festlegen, welche Wörter das Modell verwenden darf oder nicht, welche Themen im Fokus stehen oder vermieden werden sollen oder welches Format bzw. welcher Stil für die Antwort zu verwenden ist.	Text
`examples` (optional)	Beispiele für das Modell, um zu lernen, auf die Unterhaltung zu antworten.	[{ "input": {"content": "provide content"}, "output": {"content": "provide content"} }]
`messages` (erforderlich)	Unterhaltungsverlauf, der dem Modell in einem strukturierten alternate-author-Format bereitgestellt wird. Nachrichten werden in chronologischer Reihenfolge angezeigt: älteste zuerst, neueste zuletzt. Führt der Verlauf der Nachrichten dazu, dass die Eingabe die maximale Länge überschreitet, werden die ältesten Nachrichten entfernt, bis die Eingabeaufforderung innerhalb des zulässigen Limits liegt.	[{ "author": "user", "content": "user message" }]
`temperature`	Die Temperatur wird für die Probenahme während der Antwortgenerierung verwendet. Dies passiert, wenn `topP` und `topK` angewendet werden. Die Temperatur bestimmt den Grad der Zufälligkeit bei der Tokenauswahl. Niedrigere Temperaturen eignen sich gut für Prompts, die eine weniger offene oder kreative Antwort erfordern, während höhere Temperaturen zu vielfältigeren oder kreativeren Ergebnissen führen können. Eine Temperatur von `0` bedeutet, dass immer die Tokens mit der höchsten Wahrscheinlichkeit ausgewählt werden. In diesem Fall sind die Antworten auf einen bestimmten Prompt größtenteils deterministisch, aber eine gewisse Variation ist dennoch möglich. Wenn das Modell eine zu allgemeine oder zu kurze Antwort zurückgibt, oder wenn das Modell eine Fallback-Antwort ausgibt, versuchen Sie, die Temperatur zu erhöhen.	`0.0–1.0` `Default: 0.0`
`maxOutputTokens`	Maximale Anzahl an Tokens, die in der Antwort generiert werden können. Ein Token besteht aus etwa vier Zeichen. 100 Tokens entsprechen etwa 60–80 Wörtern. Geben Sie kürzere Werte für kürzere Antworten und höhere Werte für längere Antworten an.	`1–2048` `Default: 1024`
`topK`	Der Wert „Top-K“ ändert, wie das Modell Tokens für die Ausgabe auswählt. Ein „Top-K“ von `1` bedeutet, dass das nächste ausgewählte Token unter den Tokens im Modell-Vokabular (auch als gierige Decodierung bezeichnet) am wahrscheinlichsten ist, während ein „Top-K“ von `3` bedeutet, dass das nächste Token mithilfe der Temperatur aus den drei wahrscheinlichsten Tokens ausgewählt wird. Für jeden Tokenauswahlschritt werden die „Top-K“-Tokens mit den höchsten Wahrscheinlichkeiten abgetastet. Anschließend werden Tokens weiter auf der Grundlage von „Top-P“ gefiltert, wobei das endgültige Token mithilfe von Temperaturproben ausgewählt wird. Geben Sie einen niedrigeren Wert für weniger zufällige Antworten und einen höheren Wert für zufälligere Antworten an.	`1–40` `Default: 40`
`topP`	Der Wert „Top-P“ ändert, wie das Modell Tokens für die Ausgabe auswählt. Die Tokens werden von den wahrscheinlichsten (siehe „Top-K“) bis zu den unwahrscheinlichsten Werten ausgewählt, bis die Summe ihrer Wahrscheinlichkeiten dem „Top-P“-Wert entspricht. Beispiel: Wenn die Tokens A, B und C eine Wahrscheinlichkeit von 0,3, 0,2 und 0,1 haben und der „Top-P“-Wert `0.5` ist, wählt das Modell anhand der Temperatur entweder A oder B als das nächste Token und C als Kandidaten ausschließen. Geben Sie einen niedrigeren Wert für weniger zufällige Antworten und einen höheren Wert für zufälligere Antworten an.	`0.0–1.0` `Default: 0.95`
`stopSequences`	Gibt eine Liste an Strings an, die das Modell anweist, Text nicht mehr zu generieren, wenn einer der Strings in der Antwort gefunden wird. Kommt ein String mehrmals in der Antwort vor, so wird die Antwort an der Stelle abgeschnitten, an der er erfasst wurde. Bei Strings wird zwischen Groß- und Kleinschreibung unterschieden. Wenn zum Beispiel folgende Antwort zurückgegeben wird und `stopSequences` nicht angegeben ist: `public static string reverse(string myString)` Dann lautet zurückgegebene Antwort mit `stopSequences` auf `["Str", "reverse"]` gesetzt: `public static string`	`default: []`
`groundingConfig`	Mit Fundierung können Sie bei der Verwendung von Sprachmodellen auf bestimmte Daten verweisen. Wenn Sie ein Modell fundieren, kann das Modell auf interne, vertrauliche und anderweitig spezifische Daten aus Ihrem Repository verweisen und die Daten in die Antwort aufnehmen. Nur Datenspeicher von Vertex AI Search werden unterstützt.	Der Pfad muss das folgende Format haben: `projects/{project_id}/locations/global/collections/{collection_name}/dataStores/{DATA_STORE_ID}`
`candidateCount`	Die Anzahl der zurückzugebenden Antwortvarianten.	`1–4` `Default: 1`
`logprobs`	Gibt die wahrscheinlichsten Kandidaten-Token von `logprobs` mit ihren Log-Wahrscheinlichkeiten bei jedem Generierungsschritt zurück. Die ausgewählten Tokens und ihre Logwahrscheinlichkeiten bei jedem Schritt werden immer zurückgegeben. Das ausgewählte Token befindet sich möglicherweise in den oberen `logprobs` der wahrscheinlichsten Kandidaten.	`0-5`
`frequencyPenalty`	Positive Werte nehmen Abzüge bei Tokens vor, die wiederholt im generierten Text angezeigt werden, wodurch die Wahrscheinlichkeit wiederholter Inhalte verringert wird. Akzeptable Werte sind `-2.0`–`2.0`.	`Minimum value: -2.0` `Maximum value: 2.0`
`presencePenalty`	Positive Werte nehmen Abzüge bei Tokens vor, die wiederholt im generierten Text angezeigt werden, wodurch die Wahrscheinlichkeit wiederholter Inhalte verringert wird. Akzeptable Werte sind `-2.0`–`2.0`.	`Minimum value: -2.0` `Maximum value: 2.0`
`seed`	Decoder generiert ein zufälliges Rauschen mit einem Pseudozufallszahlengenerator. Vor der Stichprobenerfassung wird Logits ein Temperaturrauschen* hinzugefügt. Der Pseudozufallszahlengenerator (prng) verwendet einen Seed als Eingabe, generiert dieselbe Ausgabe mit demselben Seed. Wenn das Seed nicht festgelegt wird, ist der im Decoder verwendete Seed nicht deterministisch, sodass auch das generierte Zufallsrauschen nicht deterministisch ist. Wenn das Seed festgelegt ist, ist das erzeugte zufällige Rauschen deterministisch.	`Optional`

Beispielanfrage

REST

Senden Sie zum Testen eines Textchats mit der Vertex AI API eine POST-Anfrage an den Endpunkt des Publisher-Modells.

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

PROJECT_ID: Ihre Projekt-ID.

Informationen zu anderen Feldern finden Sie in der Tabelle Anfragetext unten.

HTTP-Methode und URL:

POST https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/publishers/google/models/chat-bison:predict

JSON-Text der Anfrage:

{
  "instances": [{
      "context":  "CONTEXT",
      "examples": [
       { 
          "input": {"content": "EXAMPLE_INPUT"},
          "output": {"content": "EXAMPLE_OUTPUT"}
       }],
      "messages": [
       { 
          "author": "AUTHOR",
          "content": "CONTENT",
       }],
   }],
  "parameters": {
    "temperature": TEMPERATURE,
    "maxOutputTokens": MAX_OUTPUT_TOKENS,
    "topP": TOP_P,
    "topK": TOP_K
  }
}

Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

curl

Hinweis: Der folgende Befehl setzt voraus, dass Sie sich mit Ihrem Nutzerkonto bei der gcloud CLI angemeldet haben. Dazu haben Sie gcloud init oder gcloud auth login ausgeführt oder die Cloud Shell genutzt, die Sie automatisch bei der gcloud CLI anmeldet. Um herauszufinden, welches Konto gerade aktiv ist, führen Sie gcloud auth list aus.

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/publishers/google/models/chat-bison:predict"

PowerShell

Hinweis: Der folgende Befehl setzt voraus, dass Sie sich mit Ihrem Nutzerkonto bei der gcloud CLI angemeldet haben. Dazu führen Sie gcloud init oder gcloud auth login aus. Um herauszufinden, welches Konto gerade aktiv ist, führen Sie gcloud auth list aus.

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/publishers/google/models/chat-bison:predict" | Select-Object -Expand Content

Sie sollten eine JSON-Antwort ähnlich wie die Beispielantwort erhalten.

Python

Informationen zur Installation des Vertex AI SDK for Python finden Sie unter Vertex AI SDK for Python installieren. Weitere Informationen finden Sie in der Referenzdokumentation zur Python API.



def send_chat() -> str:
    from vertexai.language_models import ChatModel, InputOutputTextPair

    chat_model = ChatModel.from_pretrained("chat-bison@002")

    parameters = {
        "temperature": 0.2,
        "max_output_tokens": 256,
        "top_p": 0.95,
        "top_k": 40,
    }

    chat = chat_model.start_chat(
        context="My name is Miles. You are an astronomer, knowledgeable about the solar system.",
        examples=[
            InputOutputTextPair(
                input_text="How many moons does Mars have?",
                output_text="The planet Mars has two moons, Phobos and Deimos.",
            ),
        ],
    )

    response = chat.send_message(
        "How many planets are there in the solar system?", **parameters
    )
    print(response.text)

    return response.text

Node.js

Bevor Sie dieses Beispiel anwenden, folgen Sie den Node.js-Einrichtungsschritten in der Vertex AI-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Vertex AI Node.js API.

Richten Sie zur Authentifizierung bei Vertex AI Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

/**
 * TODO(developer): Uncomment these variables before running the sample.\
 * (Not necessary if passing values as arguments)
 */
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';
const aiplatform = require('@google-cloud/aiplatform');

// Imports the Google Cloud Prediction service client
const {PredictionServiceClient} = aiplatform.v1;

// Import the helper module for converting arbitrary protobuf.Value objects.
const {helpers} = aiplatform;

// Specifies the location of the api endpoint
const clientOptions = {
  apiEndpoint: 'us-central1-aiplatform.googleapis.com',
};
const publisher = 'google';
const model = 'chat-bison@001';

// Instantiates a client
const predictionServiceClient = new PredictionServiceClient(clientOptions);

async function callPredict() {
  // Configure the parent resource
  const endpoint = `projects/${project}/locations/${location}/publishers/${publisher}/models/${model}`;

  const prompt = {
    context:
      'My name is Miles. You are an astronomer, knowledgeable about the solar system.',
    examples: [
      {
        input: {content: 'How many moons does Mars have?'},
        output: {
          content: 'The planet Mars has two moons, Phobos and Deimos.',
        },
      },
    ],
    messages: [
      {
        author: 'user',
        content: 'How many planets are there in the solar system?',
      },
    ],
  };
  const instanceValue = helpers.toValue(prompt);
  const instances = [instanceValue];

  const parameter = {
    temperature: 0.2,
    maxOutputTokens: 256,
    topP: 0.95,
    topK: 40,
  };
  const parameters = helpers.toValue(parameter);

  const request = {
    endpoint,
    instances,
    parameters,
  };

  // Predict request
  const [response] = await predictionServiceClient.predict(request);
  console.log('Get chat prompt response');
  const predictions = response.predictions;
  console.log('\tPredictions :');
  for (const prediction of predictions) {
    console.log(`\t\tPrediction : ${JSON.stringify(prediction)}`);
  }
}

callPredict();

Java

Bevor Sie dieses Beispiel anwenden, folgen Sie den Java-Einrichtungsschritten in der Vertex AI-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Vertex AI Java API.

Richten Sie zur Authentifizierung bei Vertex AI Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.


import com.google.cloud.aiplatform.v1beta1.EndpointName;
import com.google.cloud.aiplatform.v1beta1.PredictResponse;
import com.google.cloud.aiplatform.v1beta1.PredictionServiceClient;
import com.google.cloud.aiplatform.v1beta1.PredictionServiceSettings;
import com.google.protobuf.Value;
import com.google.protobuf.util.JsonFormat;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

// Send a Predict request to a large language model to test a chat prompt
public class PredictChatPromptSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String instance =
        "{\n"
            + "   \"context\":  \"My name is Ned. You are my personal assistant. My favorite movies"
            + " are Lord of the Rings and Hobbit.\",\n"
            + "   \"examples\": [ { \n"
            + "       \"input\": {\"content\": \"Who do you work for?\"},\n"
            + "       \"output\": {\"content\": \"I work for Ned.\"}\n"
            + "    },\n"
            + "    { \n"
            + "       \"input\": {\"content\": \"What do I like?\"},\n"
            + "       \"output\": {\"content\": \"Ned likes watching movies.\"}\n"
            + "    }],\n"
            + "   \"messages\": [\n"
            + "    { \n"
            + "       \"author\": \"user\",\n"
            + "       \"content\": \"Are my favorite movies based on a book series?\"\n"
            + "    }]\n"
            + "}";
    String parameters =
        "{\n"
            + "  \"temperature\": 0.3,\n"
            + "  \"maxDecodeSteps\": 200,\n"
            + "  \"topP\": 0.8,\n"
            + "  \"topK\": 40\n"
            + "}";
    String project = "YOUR_PROJECT_ID";
    String publisher = "google";
    String model = "chat-bison@001";

    predictChatPrompt(instance, parameters, project, publisher, model);
  }

  static void predictChatPrompt(
      String instance, String parameters, String project, String publisher, String model)
      throws IOException {
    PredictionServiceSettings predictionServiceSettings =
        PredictionServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (PredictionServiceClient predictionServiceClient =
        PredictionServiceClient.create(predictionServiceSettings)) {
      String location = "us-central1";
      final EndpointName endpointName =
          EndpointName.ofProjectLocationPublisherModelName(project, location, publisher, model);

      Value.Builder instanceValue = Value.newBuilder();
      JsonFormat.parser().merge(instance, instanceValue);
      List<Value> instances = new ArrayList<>();
      instances.add(instanceValue.build());

      Value.Builder parameterValueBuilder = Value.newBuilder();
      JsonFormat.parser().merge(parameters, parameterValueBuilder);
      Value parameterValue = parameterValueBuilder.build();

      PredictResponse predictResponse =
          predictionServiceClient.predict(endpointName, instances, parameterValue);
      System.out.println("Predict Response");
    }
  }
}

Antworttext

{
  "predictions": [
    {
      "candidates": [
        {
          "author": string,
          "content": string
        }
      ],
      "citationMetadata": {
        "citations": [
          {
            "startIndex": integer,
            "endIndex": integer,
            "url": string,
            "title": string,
            "license": string,
            "publicationDate": string
          }
        ]
      },
      "logprobs": {
        "tokenLogProbs": [ float ],
        "tokens": [ string ],
        "topLogProbs": [ { map<string, float> } ]
      },
      "safetyAttributes": {
        "categories": [ string ],
        "blocked": false,
        "scores": [ float ],
        "errors": [ int ]
      }
    }
  ],
  "metadata": {
    "tokenMetadata": {
      "input_token_count": {
        "total_tokens": integer,
        "total_billable_characters": integer
      },
      "output_token_count": {
        "total_tokens": integer,
        "total_billable_characters": integer
      }
    }
  }
}

Antwortelement	Beschreibung
`content`	Text der Chatnachricht.
`candidates`	Das Chatergebnis, das aus der relevanten Nachricht generiert wurde.
`categories`	Die Anzeigenamen von mit den generierten Inhalten verknüpften Sicherheitsattributkategorien. Die Reihenfolge entspricht den Scores.
`author`	Autoren-Tag für die Runde.
`scores`	Ein Konfidenzwert für die einzelnen Kategorien; ein höherer Wert bedeutet mehr Vertrauen.
`blocked`	Ein Flag, das angibt, ob die Ein- oder Ausgabe des Modells blockiert wurde.
`startIndex`	Gibt in der Vorhersageausgabe an, wo das Zitat beginnt (einschließlich). Muss >= 0 und < end_index sein.
`endIndex`	Gibt in der Vorhersageausgabe an, wo das Zitat endet (exklusiv). Muss > start_index und < len(output) sein.
`url`	Mit diesem Zitat verknüpfte URL. Sofern vorhanden, verweist diese URL auf die Webseite der Quelle dieses Zitats. Mögliche URLs sind Nachrichtenwebsites, GitHub-Repositories usw.
`title`	Titel, der mit diesem Zitat verknüpft ist. Wenn vorhanden, bezieht er sich auf den Titel der Quelle des Zitats. Mögliche Titel sind beispielsweise Nachrichtentitel oder Buchtitel.
`license`	Mit dieser Rezitation verknüpfte Lizenz. Falls vorhanden, bezieht sie sich auf die Lizenz der Quelle dieses Zitats. Mögliche Lizenzen sind Codelizenzen, z. B. mit-Lizenz.
`publicationDate`	Veröffentlichungsdatum, das mit dem Zitat verknüpft ist. Falls vorhanden, bezieht sich dies auf das Datum, an dem die Quelle des Zitats veröffentlicht wurde. Mögliche Formate sind JJJJ, JJJJ-MM, JJJJ-MM-TT.
`safetyAttributes`	Eine Sammlung von Kategorien und zugehörigen Konfidenzwerten. 1:1-Zuordnung zu `candidates`.
`input_token_count`	Anzahl der Eingabetokens. Dies ist die Gesamtzahl der Tokens für alle Nachrichten, Beispiele und Kontexte.
`output_token_count`	Anzahl der Ausgabetokens. Dies ist die Gesamtzahl der Tokens in `content` für alle Kandidaten in der Antwort.
`tokens`	Die Stichprobentokens.
`tokenLogProbs`	Die Logwahrscheinlichkeit der Stichprobentokens.
`topLogProb`	Die wahrscheinlichsten Tokens und ihre Logwahrscheinlichkeit bei jedem Schritt
`logprobs`	Ergebnisse des Parameters „logprobs”. 1:1-Zuordnung zu "Kandidaten".

Beispielantwort

{
  "predictions": [
    {
      "citationMetadata": {
        "citations": []
      },
      "safetyAttributes": {
        "scores": [
          0.1
        ],
        "categories": [
          "Finance"
        ],
        "blocked": false
      },
      "candidates": [
        {
          "author": "AUTHOR",
          "content": "RESPONSE"
        }
      ]
    }
  ]
}

Streamantwort von Modellen der generativen KI.

Die Parameter für Streaming- und Nicht-Streaming-Anfragen an die APIs sind identisch.

Beispiele für die Verwendung von REST API-Beispielanfragen und -Antworten finden Sie unter Beispiele, die die Streaming-REST-API verwenden.

Um Beispielcodeanfragen und -antworten mit dem Vertex AI SDK für Python anzuzeigen, lesen Sie Beispiele, die Vertex AI SDK für Python zum Streaming verwenden.