OpenAPI 3.1

Kunden-API-Referenz

Diese Seite beschreibt die unterstützte Kundenanfrage für Inferenz und ihre Antwort. Laden Sie für Ihre Tools das maschinenlesbare OpenAPI-Dokument herunter.

OpenAPI-JSON herunterladen

Beispiele zur Modell-API

Wählen Sie eine veröffentlichte Modellkennung, ein API-Protokoll und eine Sprache aus, um ein Anfragebeispiel anzuzeigen. Bewahren Sie Kunden-API-Schlüssel auf einem vertrauenswürdigen Server auf.

Modell

Sprache

Protokollanforderungen

OpenAI-kompatible Anfragen verwenden POST /chat/completions an der konfigurierten Kunden-API-Basis-URL (Standard: https://fusionpointai.com/api/v1). Authentifizieren Sie sich mit Authorization: Bearer und einem Kundenschlüssel mit Inferenzzugriff. Die vollständige Standard-URL lautet https://fusionpointai.com/api/v1/chat/completions.

Unterstützte Funktionen

Der aktuelle OpenAI-kompatible Chat-Endpunkt verarbeitet synchrone Textnachrichten. Dieser Endpunkt unterstützt weder Streaming noch Tool-Aufrufe.

Client installieren

Installieren Sie die Python- und Node.js-Clients als getrennte Pakete:

Python: pip install openai anthropic

Node.js: npm install openai @anthropic-ai/sdk

curl 'https://fusionpointai.com/api/v1/chat/completions' \
  -H "Authorization: Bearer $FUSIONPOINTAI_API_KEY" \
  -H "Content-Type: application/json" \
  --data '{
    "model": "Astra 6",
    "messages": [
        {
            "role": "user",
            "content": "Summarize this in one sentence."
        }
    ],
    "temperature": 0.7,
    "max_tokens": 300
}'

Anfragemuster

API-Schlüssel sicher einrichten

Erstellen Sie einen Kundenschlüssel mit Inferenzzugriff und stellen Sie ihn einem Serverprozess über dessen Secret-Manager oder Umgebung bereit.

Setzen Sie FUSIONPOINTAI_API_KEY in der Serverumgebung. Hinterlegen Sie den Schlüssel weder im Browsercode noch in der Versionsverwaltung.
Verwenden Sie HTTPS und beschränken Sie den Schlüssel auf das benötigte Konto und die erforderlichen Inferenzrechte.
Entfernen Sie Authorization- und x-api-key-Header aus Protokollen, Traces und Supportanfragen. Widerrufen Sie einen möglicherweise offengelegten Schlüssel.

export FUSIONPOINTAI_API_KEY="YOUR_CUSTOMER_API_KEY"

Exakte Modellkennung auswählen

Das Modellfeld ist ein Routingwert, kein Anzeigename. Wählen Sie eine Kennung, die im aktuellen Modellkatalog veröffentlicht ist.

Wählen Sie ein aktives oder älteres Modell, das für Inferenz als verfügbar markiert ist.
Kopieren Sie seine Kennung exakt einschließlich Satzzeichen und Versionszusatz. Leiten Sie keine Kennung aus dem Modellnamen ab.
Ist keine Kennung veröffentlicht, warten Sie auf den Katalogeintrag, statt einen Wert zu erraten.

model_id = "Astra 6"
# Use this exact identifier with either protocol.

System- und mehrstufige Nachrichten senden

Behalten Sie die ursprüngliche Reihenfolge der Gesprächsbeiträge bei und verwenden Sie nur Rollen und Inhaltsformen, die das gewählte Protokoll und Modell unterstützen.

Senden Sie bei OpenAI-kompatiblen Anfragen Nachrichten von system, user und assistant als geordnete Einträge mit Textinhalt.
Übermitteln Sie bei Claude Messages Systemanweisung und geordnete user-/assistant-Beiträge in den protokolleigenen Feldern.
Bewahren Sie nur den für Ihre Anwendung nötigen Gesprächskontext auf und beachten Sie das Kontextlimit des ausgewählten Modells.

response = client.messages.create(
    model="Astra 6",
    max_tokens=512,
    system="Answer in clear, concise German.",
    messages=[
        {"role": "user", "content": "What is an API?"},
        {"role": "assistant", "content": "An API lets software exchange requests and responses."},
        {"role": "user", "content": "Give a practical example."},
    ],
)
for block in response.content:
    if block.type == "text":
        print(block.text)

JSON-Antworten anfordern

Wenn Ihre Anwendung strukturierte Ausgaben benötigt, prüfen Sie die Antwort anhand Ihres eigenen Schemas, bevor Sie sie verwenden.

Verwenden Sie nur die strukturierten Ausgabeoptionen, die das ausgewählte Protokoll und Upstream-Modell unterstützen.
Behandeln Sie generiertes JSON als nicht vertrauenswürdige Eingabe: Parsen Sie es, prüfen Sie Felder und Typen und behandeln Sie ungültige Ausgaben.
Nehmen Sie einen JSON-Modus nicht als unterstützt an, sofern die Modelldokumentation das nicht bestätigt.

import json

# JSON is generated content, not trusted application input.
response = client.messages.create(
    model="Astra 6", max_tokens=256,
    messages=[{"role": "user", "content": 'Return only JSON with a string field named "summary". Explain an API in one sentence.'}],
)
text = "".join(block.text for block in response.content if block.type == "text")
try:
    result = json.loads(text)
    if not isinstance(result, dict) or not isinstance(result.get("summary"), str):
        raise ValueError("Unexpected response schema")
    print(result["summary"])
except (json.JSONDecodeError, ValueError) as error:
    print("Handle invalid model output:", error)

SSE-Ausgabe in Echtzeit empfangen

Streaming hängt vom Protokoll und Upstream-Modell ab. Eine gewöhnliche JSON-Antwort ist kein Stream.

OpenAI-kompatibler Chat liefert derzeit synchronen Text und unterstützt kein Streaming.
Verwenden Sie bei Claude Messages den stream-Modus, sofern das gewählte Upstream-Modell ihn unterstützt; der Proxy leitet native Server-Sent Events weiter.
Verarbeiten Sie Ereignisse fortlaufend, beenden Sie den Empfang bei Abschluss oder Fehler und behandeln Sie Teilausgaben nicht als fertige Antwort.

# client is the Anthropic client configured above.
with client.messages.stream(
    model="Astra 6", max_tokens=512,
    messages=[{"role": "user", "content": "Explain API authentication."}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)
    final_message = stream.get_final_message()
print("\nStop reason:", final_message.stop_reason)

Tools, Inhaltsblöcke und Fehler behandeln

Erhalten Sie protokolleigene Datenstrukturen und legen Sie das Verhalten Ihrer Anwendung für Tool-Aufrufe, multimodale Inhalte und Fehler ausdrücklich fest.

OpenAI-kompatibler Chat unterstützt derzeit weder Tool-Aufrufe noch nicht textuelle Inhaltsblöcke.
Claude erhält native Inhaltsblöcke sowie Tool-Aufruf- und Ergebnisdaten, sofern das gewählte Upstream-Modell dies unterstützt. Prüfen Sie Toolnamen und Argumente vor der Ausführung.
Prüfen Sie HTTP-Status und Antworttext, unterscheiden Sie Authentifizierungs-, Berechtigungs-, Validierungs- und Ratenbegrenzungsfehler und wiederholen Sie vorübergehende Fehler mit Wartezeit.

import json
from datetime import datetime, timezone
from anthropic import APIError

messages = [{"role": "user", "content": "What time is it in UTC?"}]
tools = [{
    "name": "current_utc_time", "description": "Read the current UTC time.",
    "input_schema": {"type": "object", "properties": {}, "additionalProperties": False},
}]
try:
    reply = client.messages.create(model="Astra 6", max_tokens=256, messages=messages, tools=tools)
    results = []
    for block in reply.content:
        if block.type == "tool_use":
            if block.name != "current_utc_time" or block.input != {}:
                raise ValueError("Unapproved tool request")
            results.append({"type": "tool_result", "tool_use_id": block.id,
                            "content": json.dumps({"utc": datetime.now(timezone.utc).isoformat()})})
    if results:
        messages.append({"role": "assistant", "content": reply.content})
        messages.append({"role": "user", "content": results})
        reply = client.messages.create(model="Astra 6", max_tokens=256, messages=messages, tools=tools)
    print("".join(block.text for block in reply.content if block.type == "text"))
except APIError as error:
    # Log status only; never log keys or private prompts.
    print("API request failed:", getattr(error, "status_code", None))

Häufig gestellte Fragen

Kann ich in einer Anfrage den Anzeigenamen eines Modells verwenden?

Verwenden Sie nur die exakt veröffentlichte Inferenzkennung. Der Anzeigename ist kein Routingwert. Eine nicht veröffentlichte Kennung darf nicht erraten werden.

Welche Umgebungsvariable enthält den Kundenschlüssel?

Verwenden Sie für beide Protokolle FUSIONPOINTAI_API_KEY. Speichern Sie ihn in einer vertrauenswürdigen Serverumgebung, nicht im Clientcode oder in Protokollen.

Welche URL soll der OpenAI-Client verwenden?

Verwenden Sie die konfigurierte Kunden-API-Basis-URL, standardmäßig https://fusionpointai.com/api/v1. Der Chat-Completions-Endpunkt ergänzt /chat/completions.

Warum unterscheidet sich die Basis-URL des Claude SDK von cURL?

Das Anthropic SDK ergänzt /v1/messages. Setzen Sie seine Basis-URL daher auf https://fusionpointai.com/api. Eine direkte HTTP-Anfrage verwendet die vollständige URL /api/v1/messages.

Unterstützt OpenAI-kompatibler Chat Streaming oder Tools?

Nein. Der aktuelle Endpunkt unterstützt nur synchrone Textnachrichten, kein Streaming und keine Tool-Aufrufe.

Unterstützen alle Claude-Modelle Inhaltsblöcke, Tools oder Streaming?

Nein. Native Funktionen bleiben erhalten, wenn das ausgewählte Upstream-Modell sie unterstützt. Prüfen Sie die Modellfunktionen und behandeln Sie nicht unterstützte Anfragen.

Claude Messages · `POST /messages`

Claude-Messages-Anfragen verwenden POST /api/v1/messages. Senden Sie den Kundenschlüssel in x-api-key und setzen Sie anthropic-version auf 2023-06-01. Die Basis-URL des Anthropic SDK lautet https://fusionpointai.com/api, da das SDK /v1/messages ergänzt. Bearer-Authentifizierung wird ebenfalls unterstützt.

Der Claude-Messages-Proxy erhält native Inhaltsblöcke, Tool-Daten und echtes Server-Sent-Event-Streaming, sofern das ausgewählte Upstream-Modell diese Funktionen unterstützt.

Feld	Typ	Erforderlich	Einschränkungen
`model`	`string`	Ja	`{"minLength":1,"maxLength":160}`
`max_tokens`	`integer`	Ja	`{"minimum":1,"maximum":100000}`
`messages`	`array`	Ja	`{"minItems":1,"maxItems":100,"items":{"type":"object","required":["role","content"],"properties":{"role":{"type":"string","enum":["user","assistant"]},"content":{"oneOf":[{"type":"string"},{"type":"array","items":{"type":"object","required":["type"],"properties":{"type":{"type":"string","maxLength":80}},"additionalProperties":true}}]}}}}`
`system`	`string \| array`	Nein	`{"oneOf":[{"type":"string"},{"type":"array","items":{"type":"object","required":["type","text"],"properties":{"type":{"const":"text"},"text":{"type":"string"}},"additionalProperties":true}}]}`
`stream`	`boolean`	Nein	`{"default":false}`
`temperature`	`number`	Nein	`{"minimum":0,"maximum":1}`
`top_p`	`number`	Nein	`{"minimum":0,"maximum":1}`
`top_k`	`integer`	Nein	`{"minimum":0,"maximum":100000}`
`stop_sequences`	`array`	Nein	`{"items":{"type":"string"}}`
`tools`	`array`	Nein	`{"items":{"type":"object","additionalProperties":true}}`
`tool_choice`	`object`	Nein	`{"additionalProperties":true}`
`thinking`	`object`	Nein	`{"additionalProperties":true}`
`metadata`	`object`	Nein	`{"additionalProperties":true}`
`output_config`	`object`	Nein	`{"additionalProperties":true}`
`service_tier`	`string`	Nein	`[]`

{
    "id": "msg_example",
    "type": "message",
    "role": "assistant",
    "model": "Astra 6",
    "content": [
        {
            "type": "text",
            "text": "A concise answer to the supplied question."
        }
    ],
    "stop_reason": "end_turn",
    "stop_sequence": null,
    "usage": {
        "input_tokens": 12,
        "output_tokens": 10
    }
}

{"type":"error","error":{"type":"authentication_error","message":"Invalid or missing API key."}}

Schnelleinstieg mit SDKs

Verwenden Sie die Produktions-Basis-URL mit einem kompatiblen Python- oder Node.js-Client oder senden Sie dieselbe JSON-Anfrage mit cURL.

API-Basis-URL: https://fusionpointai.com/api/v1

Senden Sie den Kunden-API-Schlüssel im Header Authorization: Bearer. Der Schlüssel muss den Scope ai:inference und Kontozugriff auf den Service besitzen. Bewahren Sie ihn auf einem vertrauenswürdigen Server auf.

# Install the client for your application language.
# Python:
python -m pip install openai
# Node.js:
npm install openai

# Bash: enter the key without storing it in shell history.
read -rs -p 'FusionPointAI API key: ' FUSIONPOINTAI_API_KEY
export FUSIONPOINTAI_API_KEY
printf '\n'
# After finishing:
# unset FUSIONPOINTAI_API_KEY

curl 'https://fusionpointai.com/api/v1/chat/completions' \
  -H "Authorization: Bearer $FUSIONPOINTAI_API_KEY" \
  -H "Content-Type: application/json" \
  --data '{
    "model": "Jurassic-2",
    "messages": [
        {
            "role": "user",
            "content": "Summarize this in one sentence."
        }
    ],
    "temperature": 0.7,
    "max_tokens": 300
}'

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["FUSIONPOINTAI_API_KEY"],
    base_url="https://fusionpointai.com/api/v1",
)

response = client.chat.completions.create(
    model="Jurassic-2",
    messages=[{"role": "user", "content": "Summarize this in one sentence."}],
    temperature=0.7,
    max_tokens=300,
)
print(response.choices[0].message.content)

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.FUSIONPOINTAI_API_KEY,
  baseURL: "https://fusionpointai.com/api/v1",
});

const response = await client.chat.completions.create({
  model: "Jurassic-2",
  messages: [{ role: "user", content: "Summarize this in one sentence." }],
  temperature: 0.7,
  max_tokens: 300,
});
console.log(response.choices[0].message.content);

OpenAI · Anfragefelder

Als Modellwerte sind die exakten registrierten Kennungen zu verwenden, die derzeit für Inferenz veröffentlicht sind. Falls keine veröffentlicht wurden, prüfen Sie vor einer Anfrage den Anbieterkatalog.

Feld	Typ	Erforderlich	Einschränkungen
`model`	`string`	Ja	Maximal 160 Zeichen; verwenden Sie eine exakt veröffentlichte Kennung.
`messages`	`array`	Ja	1 bis 100 Nachrichten, die der Reihe nach gesendet werden.
`messages[].role`	`string`	Ja	system, user oder assistant.
`messages[].content`	`string`	Ja	Maximal 100.000 Zeichen je Nachricht.
`temperature`	`number`	Nein	Zwischen 0 und 2.
`max_tokens`	`integer`	Nein	Zwischen 1 und 100.000; das Modell kann eine niedrigere Grenze festlegen.

Erfolgreiche Antwort

Eine erfolgreiche JSON-Antwort enthält id, object (chat.completion), created, model und choices. Eine Choice umfasst index, eine assistant-Nachricht und finish_reason. Tokenverbrauch kann ebenfalls zurückgegeben werden.

{
    "id": "chatcmpl_example",
    "object": "chat.completion",
    "created": 1700000000,
    "model": "Jurassic-2",
    "choices": [
        {
            "index": 0,
            "message": {
                "role": "assistant",
                "content": "A concise summary of the supplied text."
            },
            "finish_reason": "stop"
        }
    ],
    "usage": {
        "prompt_tokens": 12,
        "completion_tokens": 10,
        "total_tokens": 22
    }
}

Feld	Typ	Bedeutung
`id`	`string`	Eindeutige Kennung der Completion.
`object`	`string`	Antworttyp: chat.completion.
`created`	`integer`	Erstellungszeitpunkt als Unix-Zeitstempel.
`model`	`string`	Für die Completion verwendete Modellkennung.
`choices`	`array`	Completion-Alternativen mit assistant-Nachricht und Beendigungsgrund.
`usage`	`object`	Tokenzahlen, sofern zurückgegeben.

Ratenbegrenzungen und Fehler

Bei aktiven Kundenabonnements werden Anfragen und Token nicht auf ein Kontingent angerechnet; für Sandbox-Schlüssel gilt ihr veröffentlichtes Monatskontingent. Kontextfenster, Ausgabelimits und vorübergehende Verkehrsbegrenzungen gelten weiterhin. Chat Completions liefert synchronen Text; Claude Messages erhält unterstützte native Inhaltsblöcke, Tools und SSE. Prüfen Sie vor Anfragen die getrennten Operationsschemas.

Die Chat-Operation gibt Validierungs- und Anbieterfehler in einem Fehlerobjekt zurück. Authentifizierungs- und Scope-Middleware können stattdessen ein message-Feld auf oberster Ebene ausgeben. Status und Antwortformat hängen davon ab, welche Ebene die Anfrage abgewiesen hat.

HTTP-Status	Bedeutung
`200`	Completion erfolgreich erstellt.
`400`	Ungültiger Anfrage-Body oder Parameter.
`401`	Bearer-API-Schlüssel fehlt oder ist ungültig.
`403`	Erforderlicher Schlüssel-Scope oder Kontozugriff fehlt.
`429`	Anwendungsdrosselung oder vorübergehende Upstream-Verkehrsbegrenzung; mit wachsendem Abstand erneut versuchen.
`500`	Der Service konnte keine verwendbare Completion zurückgeben.