Schnellintegration

Ein-Klick-Verbindung zu über 30 führenden KI-Dienstanbietern Codefreie Migration · Intelligentes Routing · Kostenoptimierung

Kernkonzept

EvoLink verwendet eine asynchrone Aufgabenarchitektur, alle KI-Dienste werden als Aufgaben verarbeitet:

Aufgabe einreichen

Anfrage senden, sofort Aufgaben-ID erhalten

Echtzeit-Überwachung

Fortschritt abfragen, Statusaktualisierungen erhalten

Ergebnisse abrufen

Endergebnisse nach Aufgabenabschluss abrufen

Voraussetzungen

API-Schlüssel erhalten

Konto registrieren

Besuchen Sie die EvoLink-Konsole, um die Registrierung abzuschließen

Schlüssel erstellen

Gehen Sie zur API-Verwaltungsseite und klicken Sie auf „Neuer Schlüssel”

Schlüssel speichern

Kopieren Sie den generierten API-Schlüssel (Format: sk-evo-xxxxxxxxxx)

Der API-Schlüssel hat volle Kontoberechtigungen, bitte bewahren Sie ihn sicher auf. Bei Offenlegung sofort zurücksetzen.

30-Sekunden-Erlebnis

Beispiel zur Bildgenerierung

# Bildgenerierungsaufgabe einreichen
curl -X POST https://api.evolink.ai/v1/images/generations \\
  -H "Authorization: Bearer YOUR_API_KEY" \\
  -H "Content-Type: application/json" \\
  -d '{
    "model": "gpt-4o-image",
    "prompt": "A cute cat running on the grass at sunset with warm lighting"
  }'

Sofortige Antwort – Aufgabe erstellt

{
  "created": 1757156493,
  "id": "task-unified-1757156493-imcg5zqt",
  "model": "gpt-4o-image",
  "object": "image.generation.task",
  "progress": 0,
  "status": "pending",
  "task_info": {
    "can_cancel": true,
    "estimated_time": 100
  },
  "type": "image",
  "usage": {
    "billing_rule": "per_call",
    "credits_reserved": 252,
    "estimated_cost": 0.252,
    "user_group": "default"
  }
}

Aufgabenstatus abfragen

# Zurückgegebene Aufgaben-ID verwenden, um den Status abzufragen
curl https://api.evolink.ai/v1/tasks/task-unified-1757156493-imcg5zqt \\
  -H "Authorization: Bearer YOUR_API_KEY"

Antwort nach Aufgabenabschluss

{
  "created": 1757156493,
  "id": "task-unified-1757156493-imcg5zqt",
  "model": "gpt-4o-image",
  "object": "image.generation.task",
  "progress": 100,
  "results": [
    "https://tempfile.aiquickdraw.com/s/generated_image_url.png"
  ],
  "status": "completed",
  "task_info": {
    "can_cancel": false
  },
  "type": "image"
}

Multimodale KI-Fähigkeiten

🎨 Bildgenerierung

GPT-4O Image
Seedream 4.0

import requests

# GPT-4O Bildgenerierung
response = requests.post(
    "https://api.evolink.ai/v1/images/generations",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
        "model": "gpt-4o-image",
        "prompt": "A beautiful sunset over the ocean with vibrant colors",
        "size": "1024x1024",
        "n": 1
    }
)

task = response.json()
print(f"Task ID: {task['id']}")
print(f"Estimated time: {task['task_info']['estimated_time']} seconds")

# Seedream 4.0 Bildgenerierung
response = requests.post(
    "https://api.evolink.ai/v1/images/generations",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
        "model": "doubao-seedream-4.0",
        "prompt": "Futuristic city with neon lights at night"
    }
)

task = response.json()
print(f"Task created: {task['created']}")
print(f"Estimated cost: ${task['usage']['estimated_cost']}")

🎬 Videogenerierung

import requests
import time

# Veo3-Fast Videogenerierung
def generate_video():
    # Videogenerierungsaufgabe einreichen
    response = requests.post(
        "https://api.evolink.ai/v1/videos/generations",
        headers={"Authorization": "Bearer YOUR_API_KEY"},
        json={
            "model": "veo3-fast",
            "prompt": "A cat chasing butterflies in the garden, slow motion",
            "aspect_ratio": "16:9"
        }
    )

    task = response.json()
    task_id = task['id']

    print(f"Videoaufgabe erstellt: {task_id}")
    print(f"Geschätzte Fertigstellungszeit: {task['task_info']['estimated_time']} Sekunden")
    print(f"Geschätzte Kosten: ${task['usage']['estimated_cost']}")

    return task_id

# Aufgabenfortschritt überwachen
def monitor_task(task_id):
    while True:
        response = requests.get(
            f"https://api.evolink.ai/v1/tasks/{task_id}",
            headers={"Authorization": "Bearer YOUR_API_KEY"}
        )

        task = response.json()
        status = task['status']
        progress = task['progress']

        print(f"Status: {status}, Fortschritt: {progress}%")

        if status == "completed":
            return task['results'][0]  # Video-URL im Ergebnis-Array
        elif status == "failed":
            raise Exception(f"Aufgabe fehlgeschlagen: {task.get('error')}")

        time.sleep(10)  # Alle 10 Sekunden abfragen

# Anwendungsbeispiel
task_id = generate_video()
video_url = monitor_task(task_id)
print(f"Videogenerierung abgeschlossen: {video_url}")

SDK-Schnellintegration

Python SDK

import openai
import requests

class EvoLinkClient:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "https://api.evolink.ai"
        self.headers = {"Authorization": f"Bearer {api_key}"}

    def create_image(self, model, prompt, **kwargs):
        """Bildgenerierungsaufgabe erstellen"""
        response = requests.post(
            f"{self.base_url}/v1/images/generations",
            headers=self.headers,
            json={"model": model, "prompt": prompt, **kwargs}
        )
        return response.json()

    def create_video(self, model, prompt, **kwargs):
        """Videogenerierungsaufgabe erstellen"""
        response = requests.post(
            f"{self.base_url}/v1/videos/generations",
            headers=self.headers,
            json={"model": model, "prompt": prompt, **kwargs}
        )
        return response.json()

    def get_task(self, task_id):
        """Aufgabenstatus abrufen"""
        response = requests.get(
            f"{self.base_url}/v1/tasks/{task_id}",
            headers=self.headers
        )
        return response.json()

    def wait_for_completion(self, task_id, timeout=300):
        """Auf Aufgabenabschluss warten"""
        import time
        start_time = time.time()

        while time.time() - start_time < timeout:
            task = self.get_task(task_id)

            if task['status'] == 'completed':
                return task
            elif task['status'] == 'failed':
                raise Exception(f"Aufgabe fehlgeschlagen: {task.get('error')}")

            time.sleep(5)

        raise TimeoutError("Zeitüberschreitung bei der Aufgabenausführung")

# Anwendungsbeispiel
client = EvoLinkClient("YOUR_API_KEY")

# Bild generieren
task = client.create_image(
    model="gpt-4o-image",
    prompt="A modern intelligent office building"
)

result = client.wait_for_completion(task['id'])
print(f"Bild-URL: {result['results'][0]}")

JavaScript/Node.js

class EvoLinkClient {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseURL = 'https://api.evolink.ai';
  }

  async createImage(model, prompt, options = {}) {
    const response = await fetch(`${this.baseURL}/v1/images/generations`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ model, prompt, ...options })
    });

    return response.json();
  }

  async getTask(taskId) {
    const response = await fetch(`${this.baseURL}/v1/tasks/${taskId}`, {
      headers: { 'Authorization': `Bearer ${this.apiKey}` }
    });

    return response.json();
  }

  async waitForCompletion(taskId, timeout = 300000) {
    const startTime = Date.now();

    while (Date.now() - startTime < timeout) {
      const task = await this.getTask(taskId);

      if (task.status === 'completed') {
        return task;
      } else if (task.status === 'failed') {
        throw new Error(`Aufgabe fehlgeschlagen: ${task.error}`);
      }

      await new Promise(resolve => setTimeout(resolve, 5000));
    }

    throw new Error('Zeitüberschreitung bei der Aufgabenausführung');
  }
}

// Anwendungsbeispiel
async function generateImage() {
  const client = new EvoLinkClient('YOUR_API_KEY');

  try {
    // Aufgabe erstellen
    const task = await client.createImage(
      'doubao-seedream-4.0',
      'An abstract art painting with rich colors'
    );

    console.log('Aufgabe erstellt:', task.id);

    // Auf Abschluss warten
    const result = await client.waitForCompletion(task.id);
    console.log('Bildgenerierung abgeschlossen:', result.results[0]);

  } catch (error) {
    console.error('Generierung fehlgeschlagen:', error.message);
  }
}

generateImage();

Best Practices für die Produktionsumgebung

Fehlerbehandlungsstrategie

import requests
from typing import Optional
import time

class EvoLinkError(Exception):
    """EvoLink API Ausnahme-Basisklasse"""
    pass

class RateLimitError(EvoLinkError):
    """Ratenbegrenzungs-Ausnahme"""
    pass

class QuotaExhaustedError(EvoLinkError):
    """Kontingent-erschöpft-Ausnahme"""
    pass

def handle_api_call(func, *args, **kwargs):
    """Einheitliche API-Aufruf-Fehlerbehandlung"""
    max_retries = 3
    retry_delay = 1

    for attempt in range(max_retries):
        try:
            response = func(*args, **kwargs)

            if response.status_code == 200:
                return response.json()
            elif response.status_code == 429:
                # Ratenbegrenzung, warten und erneut versuchen
                wait_time = int(response.headers.get('Retry-After', retry_delay))
                print(f"Ratenbegrenzung erreicht, warte {wait_time} Sekunden vor erneutem Versuch...")
                time.sleep(wait_time)
                retry_delay *= 2
                continue
            elif response.status_code == 402:
                raise QuotaExhaustedError("Unzureichendes Kontoguthaben, bitte aufladen")
            else:
                error_data = response.json()
                raise EvoLinkError(f"API-Aufruf fehlgeschlagen: {error_data.get('error', {}).get('message')}")

        except requests.exceptions.RequestException as e:
            if attempt == max_retries - 1:
                raise EvoLinkError(f"Netzwerkanfrage fehlgeschlagen: {str(e)}")
            time.sleep(retry_delay)
            retry_delay *= 2

    raise EvoLinkError("Maximale Anzahl an Wiederholungsversuchen erreicht")

# Anwendungsbeispiel
try:
    result = handle_api_call(
        requests.post,
        "https://api.evolink.ai/v1/images/generations",
        headers={"Authorization": "Bearer YOUR_API_KEY"},
        json={"model": "gpt-4o-image", "prompt": "Test image"}
    )
    print("Aufgabe erfolgreich erstellt:", result['id'])
except QuotaExhaustedError:
    print("Bitte laden Sie in der Konsole auf: https://evolink.ai/dashboard/billing")
except EvoLinkError as e:
    print(f"API-Aufruf-Ausnahme: {e}")

Tipps zur Leistungsoptimierung

Stapelverarbeitung
Aufgabenpool-Verwaltung

import asyncio
import aiohttp

async def create_task_async(session, model, prompt):
    """Asynchrone Aufgabenerstellung"""
    async with session.post(
        "https://api.evolink.ai/v1/images/generations",
        json={"model": model, "prompt": prompt}
    ) as response:
        return await response.json()

async def batch_generate_images(prompts, model="gpt-4o-image"):
    """Stapelweise Bildgenerierung"""
    headers = {"Authorization": "Bearer YOUR_API_KEY"}

    async with aiohttp.ClientSession(headers=headers) as session:
        # Alle Aufgaben gleichzeitig erstellen
        tasks = [
            create_task_async(session, model, prompt)
            for prompt in prompts
        ]
        results = await asyncio.gather(*tasks)

        # Aufgaben-ID-Liste zurückgeben
        return [result['id'] for result in results]

# Anwendungsbeispiel
prompts = [
    "Modern office design",
    "Natural landscape painting",
    "Abstract artwork",
    "Tech-style UI interface"
]

task_ids = asyncio.run(batch_generate_images(prompts))
print(f"{len(task_ids)} Aufgaben erstellt")

from concurrent.futures import ThreadPoolExecutor
import queue
import threading

class TaskManager:
    def __init__(self, api_key, max_workers=5):
        self.api_key = api_key
        self.headers = {"Authorization": f"Bearer {api_key}"}
        self.task_queue = queue.Queue()
        self.result_queue = queue.Queue()
        self.executor = ThreadPoolExecutor(max_workers=max_workers)
        self.running = True

    def submit_task(self, model, prompt, **kwargs):
        """Aufgabe in die Warteschlange einreihen"""
        task_data = {"model": model, "prompt": prompt, **kwargs}
        future = self.executor.submit(self._process_task, task_data)
        return future

    def _process_task(self, task_data):
        """Einzelne Aufgabe verarbeiten"""
        # Aufgabe erstellen
        response = requests.post(
            "https://api.evolink.ai/v1/images/generations",
            headers=self.headers,
            json=task_data
        )
        task = response.json()

        # Auf Abschluss warten
        return self._wait_for_completion(task['id'])

    def _wait_for_completion(self, task_id):
        """Auf Aufgabenabschluss warten"""
        while True:
            response = requests.get(
                f"https://api.evolink.ai/v1/tasks/{task_id}",
                headers=self.headers
            )
            task = response.json()

            if task['status'] == 'completed':
                return task
            elif task['status'] == 'failed':
                raise Exception(f"Aufgabe fehlgeschlagen: {task.get('error')}")

            time.sleep(5)

# Anwendungsbeispiel
manager = TaskManager("YOUR_API_KEY")

futures = []
for i in range(10):
    future = manager.submit_task(
        model="gpt-4o-image",
        prompt=f"Design {i+1}"
    )
    futures.append(future)

# Alle Ergebnisse abrufen
for i, future in enumerate(futures):
    try:
        result = future.result(timeout=300)
        print(f"Aufgabe {i+1} abgeschlossen: {result['results'][0]}")
    except Exception as e:
        print(f"Aufgabe {i+1} fehlgeschlagen: {e}")

Überwachung & Analyse

Nutzungsüberwachung

Besuchen Sie die EvoLink-Konsole, um in Echtzeit zu sehen:

Echtzeit-Überwachung

API-Aufrufstatistiken
Erfolgs- und Fehlerquoten
Antwortzeitanalyse
Überwachung gleichzeitiger Anfragen

Kostenanalyse

Kostenverteilung nach Modell
Tägliche/monatliche Nutzungstrends
Kostenprognosen und Warnungen
Kontingentnutzungsstatus

Benutzerdefinierte Überwachung

import logging
from datetime import datetime

class EvoLinkMonitor:
    def __init__(self):
        # Protokollierung konfigurieren
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s',
            handlers=[
                logging.FileHandler('evolink_api.log'),
                logging.StreamHandler()
            ]
        )
        self.logger = logging.getLogger(__name__)

    def log_task_creation(self, task_id, model, cost):
        """Aufgabenerstellung protokollieren"""
        self.logger.info(f"Aufgabe erstellt | ID:{task_id} | Modell:{model} | Kosten:${cost}")

    def log_task_completion(self, task_id, duration, status):
        """Aufgabenabschluss protokollieren"""
        self.logger.info(f"Aufgabe abgeschlossen | ID:{task_id} | Dauer:{duration}s | Status:{status}")

    def log_error(self, error, context=""):
        """Fehler protokollieren"""
        self.logger.error(f"API-Fehler | {context} | {str(error)}")

# Anwendungsbeispiel
monitor = EvoLinkMonitor()

# In API-Aufrufen verwenden
start_time = time.time()
try:
    task = client.create_image("gpt-4o-image", "Test prompt")
    monitor.log_task_creation(
        task['id'],
        task['model'],
        task['usage']['estimated_cost']
    )

    result = client.wait_for_completion(task['id'])
    duration = time.time() - start_time
    monitor.log_task_completion(task['id'], int(duration), "completed")

except Exception as e:
    monitor.log_error(e, f"Task ID: {task.get('id', 'unknown')}")

Zusammenfassung der Best Practices

Entwicklungsempfehlungen

Immer Fehlerbehandlung implementieren
Asynchrone Programmierung für Effizienz nutzen
Angemessene Timeout-Werte festlegen
Detaillierte Aufrufinformationen protokollieren

Leistungsoptimierung

Stapelverarbeitung reduziert Netzwerk-Overhead
Aufgabenpools für Parallelitätsverwaltung nutzen
API-Kontingentnutzung überwachen
Häufig verwendete Ergebnisse zwischenspeichern

Sicherheitsaspekte

Sichere Aufbewahrung des API-Schlüssels
Umgebungsvariablen für die Konfiguration verwenden
Zugriffsschlüssel regelmäßig rotieren
Ungewöhnliches Aufrufverhalten überwachen

Kostenkontrolle

Angemessene Budgetgrenzen festlegen
Geeignete Modelle auswählen
Prompt-Länge optimieren
Nutzungstrends überwachen

Bereit loszulegen?

Beginnen Sie jetzt Ihre KI-Kreativreise

Konsole

API-Schlüssel verwalten und Nutzung überwachen

API-Dokumentation

Detaillierte Schnittstellendokumentation anzeigen

Aufgabenverwaltung

Mehr über Aufgabenstatusabfragen erfahren

Brauchen Sie Hilfe? Unser technisches Team steht Ihnen jederzeit mit professionellem Support zur Verfügung

Erste Schritte

​Schnellintegration

​Kernkonzept

Aufgabe einreichen

Echtzeit-Überwachung

Ergebnisse abrufen

​Voraussetzungen

​API-Schlüssel erhalten

​30-Sekunden-Erlebnis

​Beispiel zur Bildgenerierung

​Aufgabenstatus abfragen

​Multimodale KI-Fähigkeiten

​🎨 Bildgenerierung

​🎬 Videogenerierung

​SDK-Schnellintegration

​Python SDK

​JavaScript/Node.js

​Best Practices für die Produktionsumgebung

​Fehlerbehandlungsstrategie

​Tipps zur Leistungsoptimierung

​Überwachung & Analyse

​Nutzungsüberwachung

Echtzeit-Überwachung

Kostenanalyse

​Benutzerdefinierte Überwachung

​Zusammenfassung der Best Practices

Entwicklungsempfehlungen

Leistungsoptimierung

Sicherheitsaspekte

Kostenkontrolle

​Bereit loszulegen?

Konsole

API-Dokumentation

Aufgabenverwaltung

Schnellintegration

Kernkonzept

Voraussetzungen

API-Schlüssel erhalten

30-Sekunden-Erlebnis

Beispiel zur Bildgenerierung

Aufgabenstatus abfragen

Multimodale KI-Fähigkeiten

🎨 Bildgenerierung

🎬 Videogenerierung

SDK-Schnellintegration

Python SDK

JavaScript/Node.js

Best Practices für die Produktionsumgebung

Fehlerbehandlungsstrategie

Tipps zur Leistungsoptimierung

Überwachung & Analyse

Nutzungsüberwachung

Benutzerdefinierte Überwachung

Zusammenfassung der Best Practices

Bereit loszulegen?