> ## Documentation Index
> Fetch the complete documentation index at: https://docs.infercom.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Textgenerierungsfunktionen implementieren - Entwicklerhandbuch

> Textgenerierung mit der Infercom API. Streaming, Non-Streaming und asynchrone Completions mit Codebeispielen in Python und JavaScript.

Dieses Dokument beschreibt verschiedene Aspekte der Textgenerierung, einschließlich Generierungstypen, Modellauswahl, Erstellung von Prompts und Verwaltung von Konversationen mit mehreren Gesprächsrunden.

## Generierungstypen

Sie können verschiedene Methoden zur Textgenerierung verwenden, einschließlich Nicht-Streaming-, Streaming- und asynchronen Vervollständigungen.

### Einfache Generierung (ohne Streaming)

Verwenden Sie den folgenden Code, um Textgenerierung mit dem Infercom oder OpenAI Python-Client ohne Streaming durchzuführen.

<CodeGroup>
  ```python Python (SambaNova) theme={null}
  from sambanova import SambaNova
  client = SambaNova(
      base_url="https://api.infercom.ai/v1",
      api_key="ihr-infercom-api-schluessel"
  )
  completion = client.chat.completions.create(
      model="Meta-Llama-3.1-8B-Instruct",
      messages = [  
          {"role": "system", "content": "Answer the question in a couple sentences."},
          {"role": "user", "content": "Share a happy story with me"}
      ]
  )
  print(completion.choices[0].message.content)
  ```

  ```python Python (OpenAI) theme={null}
  from openai import OpenAI
  client = OpenAI(
      base_url="https://api.infercom.ai/v1",
      api_key="ihr-infercom-api-schluessel"
  )
  completion = client.chat.completions.create(
      model="Meta-Llama-3.1-8B-Instruct",
      messages = [  
          {"role": "system", "content": "Answer the question in a couple sentences."},
          {"role": "user", "content": "Share a happy story with me"}
      ]
  )
  print(completion.choices[0].message.content)
  ```
</CodeGroup>

### Asynchrone Generierung (ohne Streaming)

Für asynchrone Vervollständigungen verwenden Sie den AsyncSambaNova oder AsyncOpenAI Python-Client, wie unten dargestellt.

<CodeGroup>
  ```python Python (SambaNova) theme={null}
  from sambanova import AsyncSambaNova
  import asyncio
  async def main():
      client = AsyncSambaNova(
          base_url="https://api.infercom.ai/v1",
          api_key="ihr-infercom-api-schluessel"
      )
      completion = await client.chat.completions.create(
          model="Meta-Llama-3.1-8B-Instruct",
          messages = [
              {"role": "system", "content": "Answer the question in a couple sentences."},
              {"role": "user", "content": "Share a happy story with me"}
          ]
      )
      print(completion.choices[0].message.content)
  asyncio.run(main())
  ```

  ```python Python (OpenAI) theme={null}
  from openai import AsyncOpenAI
  import asyncio
  async def main():
      client = AsyncOpenAI(
          base_url="https://api.infercom.ai/v1",
          api_key="ihr-infercom-api-schluessel"
      )
      completion = await client.chat.completions.create(
          model="Meta-Llama-3.1-8B-Instruct",
          messages = [
              {"role": "system", "content": "Answer the question in a couple sentences."},
              {"role": "user", "content": "Share a happy story with me"}
          ]
      )
      print(completion.choices[0].message.content)
  asyncio.run(main())
  ```
</CodeGroup>

### Streaming-Antwort

Für Echtzeit-Streaming-Vervollständigungen verwenden Sie den folgenden Ansatz mit dem Infercom oder OpenAI Client.

<CodeGroup>
  ```python Python (SambaNova) theme={null}
  from sambanova import SambaNova
  client = SambaNova(
      base_url="https://api.infercom.ai/v1",
      api_key="ihr-infercom-api-schluessel"
  )
  completion = client.chat.completions.create(
      model="Meta-Llama-3.1-8B-Instruct",
      messages = [
          {"role": "system", "content": "Answer the question in a couple sentences."},
          {"role": "user", "content": "Share a happy story with me"}
      ],
      stream = True
  )
  for chunk in completion:
    print(chunk.choices[0].delta.content, end="")
  ```

  ```python Python (OpenAI) theme={null}
  from openai import OpenAI
  client = OpenAI(
      base_url="https://api.infercom.ai/v1",
      api_key="ihr-infercom-api-schluessel"
  )
  completion = client.chat.completions.create(
      model="Meta-Llama-3.1-8B-Instruct",
      messages = [
          {"role": "system", "content": "Answer the question in a couple sentences."},
          {"role": "user", "content": "Share a happy story with me"}
      ],
      stream = True
  )
  for chunk in completion:
    print(chunk.choices[0].delta.content, end="")
  ```
</CodeGroup>

## Modellauswahl

Modelle unterscheiden sich in ihrer Architektur, was ihre Geschwindigkeit und Antwortqualität beeinflusst. Die Auswahl eines Modells hängt von den unten aufgeführten Faktoren ab.

| **Faktor**                | **Überlegung**                                                                  |
| :------------------------ | :------------------------------------------------------------------------------ |
| Aufgabenkomplexität       | Größere Modelle sind besser für komplexe Aufgaben geeignet.                     |
| Genauigkeitsanforderungen | Größere Modelle bieten in der Regel eine höhere Genauigkeit.                    |
| Kosten und Ressourcen     | Größere Modelle sind mit erhöhten Kosten und Ressourcenanforderungen verbunden. |

Experimentieren Sie mit verschiedenen Modellen, um dasjenige zu finden, das am besten zu Ihrem spezifischen Anwendungsfall passt.

## Effektive Prompts erstellen

Prompt Engineering ist die Praxis, Prompts zu entwerfen und zu verfeinern, um optimale Antworten von großen Sprachmodellen (LLMs) zu erzielen. Dieser Prozess ist iterativ und erfordert Experimentieren, um die bestmöglichen Ergebnisse zu erreichen.

### Einen Prompt erstellen

Ein einfacher Prompt kann so simpel sein wie ein paar Worte, um eine Antwort vom LLM hervorzurufen. Für komplexere Anwendungsfälle können jedoch zusätzliche Elemente erforderlich sein, wie unten dargestellt.

| **Element**                        | **Beschreibung**                                                                                                    |
| :--------------------------------- | :------------------------------------------------------------------------------------------------------------------ |
| Definition einer Persona           | Zuweisung einer bestimmten Rolle an das Modell (z.B. "Sie sind ein Finanzberater").                                 |
| Bereitstellung von Kontext         | Bereitstellung von Hintergrundinformationen zur Steuerung der Modellantwort.                                        |
| Festlegung des Ausgabeformats      | Anweisung an das Modell, in einem bestimmten Stil zu antworten (z.B. JSON, Aufzählungspunkte, strukturierter Text). |
| Beschreibung eines Anwendungsfalls | Klärung des Ziels der Interaktion.                                                                                  |

### Erweiterte Prompting-Techniken

Um die Antwortqualität und das Denkvermögen zu verbessern, können fortgeschrittenere Techniken eingesetzt werden.

| **Technik**                      | **Beschreibung**                                                                           |
| :------------------------------- | :----------------------------------------------------------------------------------------- |
| In-Context Learning              | Bereitstellung von Beispielen für gewünschte Ausgaben zur Steuerung des Modells.           |
| Chain-of-Thought (CoT) Prompting | Ermutigung des Modells, seine Überlegungen zu artikulieren, bevor es eine Antwort liefert. |

Weitere Details zum Prompt Engineering finden Sie unter [A Systematic Survey of Prompt Engineering in Large Language Models: Techniques and Applications](https://arxiv.org/pdf/2402.07927).

### Nachrichten und Rollen

In Chat-basierten Interaktionen werden Nachrichten als Dictionaries mit bestimmten Rollen und Inhalten dargestellt.

| **Element** | **Beschreibung**                   |
| :---------- | :--------------------------------- |
| `role`      | Gibt an, wer die Nachricht sendet. |
| `content`   | Enthält den Nachrichtentext.       |

#### Häufige Rollen

Rollen werden typischerweise als `system`, `user` oder `assistant` kategorisiert.

| **Rolle**   | **Beschreibung**                                     |
| :---------- | :--------------------------------------------------- |
| `system`    | Stellt allgemeine Anweisungen für das Modell bereit. |
| `user`      | Repräsentiert die Benutzereingabe.                   |
| `assistant` | Enthält die Antwort des Modells.                     |
| `tool`      | Enthält ein Werkzeug-Ausführungsergebnis.            |

## Konversation mit mehreren Gesprächsrunden

Um den Kontext über mehrere Austausche hinweg aufrechtzuerhalten, werden Nachrichten in einem KI-Konversationssystem typischerweise als Liste von Dictionaries gespeichert. Jedes Dictionary enthält Schlüssel, die die Rolle des Absenders und den Nachrichteninhalt angeben. Diese Struktur hilft dem System, den Kontext über mehrere Gesprächsrunden hinweg zu verfolgen.

Unten ist ein Beispiel dafür, wie eine Konversation mit mehreren Gesprächsrunden unter Verwendung des Modells **Meta-Llama-3.1-8B-Instruct** strukturiert wird:

```python Structuring Multi-Turn Conversations in Meta-Llama-3.1-8B-Instruct using python theme={null}
completion = client.chat.completions.create(
    model="Meta-Llama-3.1-8B-Instruct",
    messages = [
        {"role": "user", "content": "Hi! My name is Peter and I am 31 years old. What is 1+1?"},
        {"role": "assistant", "content": "Nice to meet you, Peter. 1 + 1 is equal to 2"},
        {"role": "user", "content": "What is my age?"}
    ],
    stream = True
)
for chunk in completion:
  print(chunk.choices[0].delta.content, end="")
```

Nach dem Ausführen des Programms sollten Sie eine Ausgabe ähnlich der folgenden sehen.

```python Example output theme={null}
You told me earlier, Peter. You're 31 years old.
```

Durch die Strukturierung von Konversationen auf diese Weise kann das Modell den Kontext beibehalten, frühere Benutzereingaben abrufen und kohärentere Antworten liefern.

### Überlegungen für lange Konversationen

Bei langen Konversationen mit LLMs müssen bestimmte Faktoren wie Token-Limits und Speicherbeschränkungen berücksichtigt werden, um Genauigkeit und Kohärenz sicherzustellen.

* **Token-Limits** - LLMs haben ein festes Kontextfenster, das die Anzahl der Tokens begrenzt, die sie in einer einzigen Anfrage verarbeiten können. Wenn die Eingabe diese Grenze überschreitet, könnte das System sie abschneiden, was zu unvollständigen oder inkohärenten Antworten führt.
* **Speicherbeschränkungen** - Das Modell behält keinen Kontext über sein Eingabefenster hinaus bei. Um den Kontext zu bewahren, sollten frühere Nachrichten wieder in Prompts aufgenommen werden.

Durch effektive Strukturierung von Prompts und Verwaltung des Konversationsverlaufs können Sie Interaktionen mit LLMs für bessere Genauigkeit und Kohärenz optimieren.

### Reasoning-Modelle und Token-Limits

<Warning>
  **Reasoning-Tokens zählen zu Ihrem Token-Limit.** Bei Reasoning-Modellen wird die Gedankenkette (Chain-of-Thought), die das Modell vor seiner endgültigen Antwort generiert, auf `max_tokens` (bzw. `max_completion_tokens`) angerechnet. Wenn Sie dieses Limit zu niedrig setzen, kann das Modell das gesamte Budget für das Denken verbrauchen und wird abgeschnitten, **bevor** es eine sichtbare Antwort erzeugt.

  In diesem Fall kommt die Antwort leer oder abgeschnitten zurück und `finish_reason` ist `"length"`. Prüfen Sie immer `finish_reason`: Ist der Wert `"length"`, erhöhen Sie `max_tokens` und wiederholen Sie die Anfrage. Planen Sie bei Reasoning-Modellen großzügig - lassen Sie genügend Spielraum sowohl für das Reasoning als auch für die endgültige Antwort.
</Warning>

Weitere Informationen zu Reasoning-Modellen, zur Steuerung von Thinking und zur Fehlerbehebung bei abgeschnittener Ausgabe finden Sie im [Reasoning-Leitfaden](/de/build/reasoning).