Base URL: https://ecaix.com/api/ai/v1
Model:    deepseek-v4.1-flash

python -m pip install --upgrade openai

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

const response = await client.chat.completions.create({
  model: "deepseek-v4.1-flash",
  messages: [
    { role: "user", content: "Return one short sentence about API testing." },
  ],
  max_tokens: 128,
});

console.log(response.choices[0].message.content);

curl -sS -D /tmp/ecaix-deepseek-headers.txt \
  -o /tmp/ecaix-deepseek-response.json \
  -w '\nHTTP %{http_code}\n' \
  "https://ecaix.com/api/ai/v1/chat/completions" \
  -H "Authorization: Bearer ${ECAIX_API_KEY}" \
  -H "content-type: application/json" \
  -d '{
    "model": "deepseek-v4.1-flash",
    "messages": [
      {"role": "user", "content": "Reply with one short sentence."}
    ],
    "max_tokens": 128
  }'

stream = client.chat.completions.create(
    model="deepseek-v4.1-flash",
    messages=[{"role": "user", "content": "Summarize API retries in three points."}],
    stream=True,
    max_tokens=256,
)

for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end="", flush=True)

import json

response = client.chat.completions.create(
    model="deepseek-v4.1-flash",
    messages=[
        {
            "role": "user",
            "content": "Return a JSON object with keys title and priority."
        }
    ],
    response_format={"type": "json_object"},
    max_tokens=128,
)

payload = json.loads(response.choices[0].message.content)
print(payload["title"])

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_demo_status",
            "description": "Return a fixed status for a local compatibility test.",
            "parameters": {
                "type": "object",
                "properties": {},
                "additionalProperties": False,
            },
        },
    }
]

response = client.chat.completions.create(
    model="deepseek-v4.1-flash",
    messages=[{"role": "user", "content": "Check the demo status."}],
    tools=tools,
    tool_choice="auto",
    max_tokens=128,
)

print(response.choices[0].message.tool_calls)

## **Präproduktionsvalidierung und Betriebssicherheit**

Bevor die Integration des DeepSeek-APIs in die Produktionsumgebung übernommen wird, empfiehlt sich eine sorgfältige **Präproduktionsvalidierung**, um potenzielle Risiken zu identifizieren und die Zuverlässigkeit der API-Anbindung zu gewährleisten. Hier sind zentrale Aspekte, die bei der Vorbereitung und dem Betrieb zu beachten sind:

### **API-Schlüsselmanagement und Sicherheitskonzepte**
Die sichere Handhabung von API-Schlüsseln ist essenziell, um Missbrauch zu verhindern. Verwenden Sie **umgehende, zeitlich begrenzte Schlüssel** (z. B. über Short-Lived Tokens) oder integrieren Sie die Authentifizierung in einer **dedizierten API-Gateway-Lösung**, die zusätzlich zu den Standard-Authentifizierungsmechanismen (z. B. OAuth 2.0) eine **Token-Rotation** unterstützt. Vermeiden Sie die Speicherung sensibler Schlüssel in Konfigurationsdateien oder Versionierungssystemen. Stattdessen sollten sie in **geheimen Umgebungsvariablen** oder einer **dedizierten Secrets-Management-Plattform** (z. B. AWS Secrets Manager, HashiCorp Vault) abgelegt werden.

### **Modell-ID-Checks und Konsistenzprüfungen**
Vor der Freigabe des API-Einsatzes in der Produktion ist es ratsam, die korrekte Zuordnung der gewünschten **Model-ID** zu überprüfen. Nutzen Sie die **DeepSeek-API-Endpunkte für Modellinformationen** (z. B. `/models/{model_id}`), um sicherzustellen, dass die gewünschte Version des Modells tatsächlich verfügbar ist und die gewünschten Parameter (z. B. Token-Limit, Temperatur) unterstützt. Falls sich zwischen der Entwicklung und der Produktion die **Model-ID oder die API-Spezifikationen** ändern, sollten diese Änderungen **automatisch erfasst und dokumentiert** werden. In solchen Fällen empfiehlt sich eine **manuelle oder automatisierte Rückprüfung** der API-Dokumentation vor dem Deployment.

### **Logging und Debugging ohne Sensible Daten**
Die Erstellung eines **sicheren Logging-Konzepts** ist entscheidend, um die API-Anbindung zu überwachen, ohne sensible Informationen wie API-Schlüssel oder Modell-IDs zu exponieren. Nutzen Sie **maskierte Logs**, bei denen persönliche Daten (z. B. `Authorization`-Header-Werte) durch Platzhalter ersetzt werden. Wählen Sie eine **Log-Level-Strategie**, die kritische Ereignisse (z. B. Fehler, Zeitüberschreitungen) detailliert dokumentiert, während Routineaktivitäten (z. B. erfolgreiche Requests) nur mit minimalen Metadaten (z. B. Request-ID, Endpunkt, Antwortstatus) protokolliert werden.

Falls die API **Streaming-Anfragen** unterstützt, sollten auch **Streaming-Disconnects** (z. B. durch Netzwerkprobleme oder Zeitlimits) im Logging berücksichtigt werden. Hier ist es sinnvoll, die **Streaming-Frame-Informationen** (z. B. Token-Flow, Fehlercodes) zu tracken, um später die Ursache von Unterbrechungen zu analysieren.

### **Retry-Mechanismen und Idempotenz**
Die API sollte **idempotente Requests** unterstützen, um wiederholte Anfragen (z. B. bei temporären Netzwerkproblemen) zu vermeiden. Falls nicht, implementieren Sie **externe Retry-Logik** mit einer **exponentiellen Backoff-Strategie**, um die Belastung der API zu minimieren. Achten Sie darauf, dass Retry-Anfragen **nicht unlimitiert** wiederholt werden, um die Stabilität der API nicht zu gefährden. Dokumentieren Sie die **Maximalanzahl von Retries** und die **Timeout-Werte** für kritische Endpunkte.

### **Autorisierungstools und Zugriffskontrollen**
Die Integration sollte mit **Tool-Autorisierung** (z. B. über IAM-Rollen, Service-Accounts oder API-Gateways) kombiniert werden, um den Zugriff auf die DeepSeek-API zu kontrollieren. Falls die API in einer **Cloud-Umgebung** betrieben wird, sollten die zugrundeliegenden Ressourcen (z. B. Compute-Einheiten, Speicher) entsprechend dimensioniert und mit **Quoten** (z. B. Request-Raten) begrenzt werden, um Missbrauch zu verhindern.