AIRouter: ein intelligentes Routing-Werkzeug zum Aufrufen mehrerer Modelle mit einer einheitlichen API-Schnittstelle

AIRouter ist ein intelligentes Routing-Tool für Large Language Models (LLMs), das mehrere LLM-Anbieter (z. B. OpenAI, Anthropic, Google usw.) über eine einheitliche API-Schnittstelle für eine effiziente Aufgabenverteilung verbindet. AIRouter unterstützt einen intelligenten Lastausgleich und wählt das optimale Modell auf der Grundlage von Antwortzeit, Kosten und Erfolgsrate aus, während es gleichzeitig eine Echtzeit-Überwachung des Zustands und eine API-Schlüsselverwaltung bietet.AIRouter unterstützt auch multimodale Eingaben (z. B. Text und Bild) und Funktionsaufrufe, so dass es sich für Entwickler eignet, die modellübergreifend arbeiten müssen. Das Projekt basiert auf der Python-Entwicklung, unterstützt die Bereitstellung in Docker-Containern und ist sofort einsatzbereit für eine schnelle Integration in Produktionsumgebungen.

Funktionsliste

• Vereinheitlichte API-SchnittstelleZugang zu mehreren LLM-Anbietern, einschließlich OpenRouter, DeepInfra, TogetherAI usw., über eine einzige Schnittstelle.
• Intelligenter LastausgleichDynamische Zuweisung von Aufgaben an das optimale Modell auf der Grundlage von Reaktionszeit, Kosten und Erfolg.
• Gesundheitsüberwachung in EchtzeitAutomatisches Überprüfen des API-Status und Sperren nicht verfügbarer oder kostenintensiver Modelle.
• Effiziente API-SchlüsselverwaltungOptimierung der Schlüsselnutzung, Verbesserung der Leistung und automatische Vermeidung ungültiger Schlüssel.
• multimodale UnterstützungVerarbeitet Text- und Bildeingaben und Funktionsaufrufe, um verschiedene Aufgabenstellungen zu erfüllen.
• Pareoptimale WahlIntelligente Auswahl des besten Modells aus mehreren Modellen unter Berücksichtigung von Leistung und Kosten.
• KostenoptimierungSenkung der Kosten für die Verwendung kostenintensiver Modelle durch die Sperrfunktion für Gesundheitschecks.
• Containerisierte BereitstellungUnterstützt die Docker-Bereitstellung und vereinfacht so die Konfiguration der Umgebung und den Startvorgang.

Hilfe verwenden

Installation und Einrichtung

AIRouter ist ein Open-Source-Python-Projekt, das die Bereitstellung über Python-Pakete oder Docker unterstützt. Hier sind die detaillierten Schritte zur Installation und Verwendung:

1. die Vorbereitung der Umwelt

• Systemanforderungen: Installieren Sie Python 3.7 oder höher, Linux oder macOS empfohlen.
• Abhängige Werkzeuge::
  • Git installieren: zum Klonen von Code-Repositories.
  • Installieren Sie Docker (optional): für eine containerisierte Bereitstellung.
  • Installieren Sie MySQL: zum Speichern von API-Schlüsselverwendungsprotokollen.
• Überprüfen der Python-Version::

  python --version
  

  Stellen Sie sicher, dass die Version 3.7 oder höher ist.

2. das Klonen von Lagern

• Interviews https://github.com/THESIS-AGENT/AIRouterkopieren Sie die Repository-URL.
• Läuft im Terminal:

  git clone https://github.com/THESIS-AGENT/AIRouter.git
  cd AIRouter
  

3. die Installation von Abhängigkeiten

• Weg 1: Installation als Python-Paket (empfohlen)::

  pip install -e .
  

• Weg 2: Direkte Installation von Abhängigkeiten::

  pip install -r requirements.txt
  

4. die Konfiguration von Projekten

• Konfigurieren des API-Schlüssels::
  • Kopieren Sie die Beispielkonfigurationsdatei:

    cp ew_config/api_keys.example.py ew_config/api_keys_local.py
    

  • Compiler ew_config/api_keys_local.pygeben Sie den echten API-Schlüssel jedes LLM-Anbieters ein. Zum Beispiel:

    API_KEYS = {
    "openai": "sk-xxxxxxxxxxxxxxxxxxxx",
    "anthropic": "sk-ant-xxxxxxxxxxxxxxxx",
    "google": "AIzaSy-xxxxxxxxxxxxxxxx"
    }
    

• Einrichten der Datenbank::
  • Erstellen Sie eine MySQL-Datenbank:

    CREATE DATABASE airouter;
    CREATE TABLE api_key_usage (
    request_id VARCHAR(50) PRIMARY KEY,
    api_key VARCHAR(100) NOT NULL,
    model_name VARCHAR(50) NOT NULL,
    source_name VARCHAR(50) NOT NULL,
    prompt_tokens INT,
    completion_tokens INT,
    create_time DATETIME NOT NULL,
    finish_time DATETIME NOT NULL,
    execution_time FLOAT NOT NULL,
    status BOOLEAN NOT NULL
    );
    

  • Kopieren Sie die Datei mit den Umgebungsvariablen:

    cp env.example .env
    

  • Compiler .env Datei, indem Sie z. B. die Datenbankinformationen ausfüllen:

    DB_HOST=localhost
    DB_USER=root
    DB_PASSWORD=your_password
    DB_NAME=airouter
    DB_PORT=3306
    

5. die Aktivierung von Diensten

• Docker-Bereitstellung (empfohlen)::
  • Erstellen Sie das Docker-Image:

    docker build -t airouter:latest .
    

  • Starten Sie den Dienst:

    docker-compose up -d
    

  • Prüfen Sie den Status des Dienstes:

    docker-compose ps
    

• manuelle Aktivierung::
  • Einführung des Gesundheits-Screening-Dienstes:

    python CheckHealthy.py
    

  • Starten Sie den API-Schlüsselverwaltungsdienst in dem neuen Terminal:

    python -m api_key_manager.main
    

Funktion Betriebsablauf

1. grundlegende Texterstellung

• ausnutzen LLM_Wrapper Klasse ruft das Modell auf, um den Text zu erzeugen:

  from LLMwrapper import LLM_Wrapper
  response = LLM_Wrapper.generate(
  model_name="gpt4o_mini",
  prompt="解释量子计算的基本原理"
  )
  print(response)
  

• Das System wählt das optimale Modell (z. B. gpt4o_mini von OpenAI) für die Ausführung der Aufgabe auf der Grundlage der Lastausgleichspolitik aus.

2. multimodale Eingaben

• Unterstützt Bild- und Texteingabe, z.B. um den Inhalt eines Bildes zu beschreiben:

  import base64
  with open("image.jpg", "rb") as f:
  img_base64 = base64.b64encode(f.read()).decode()
  response = LLM_Wrapper.generate_mm(
  model_name="gpt4o_mini",
  prompt="描述这张图片的内容",
  img_base64=img_base64
  )
  print(response)
  

• Stellen Sie sicher, dass das Modell Multimodalität unterstützt (z. B. gpt4o_mini) und das Bild in das Base64-Format konvertiert werden muss.

3) Funktionsaufrufe

• Konfigurieren Sie das Tool und rufen Sie externe Funktionen auf, wie z. B. die Abfrage des Wetters:

  tools = [
  {
  "type": "function",
  "function": {
  "name": "get_weather",
  "description": "获取天气信息",
  "parameters": {
  "type": "object",
  "properties": {
  "location": {"type": "string", "description": "城市名称"}
  },
  "required": ["location"]
  }
  }
  }
  ]
  response = LLM_Wrapper.function_calling(
  model_name="gpt4o_mini",
  prompt="北京今天天气如何？",
  tools=tools
  )
  print(response)
  

4. den Lastausgleich konfigurieren

• Es werden drei Lastausgleichsmodi unterstützt:
  • fast_firstPriorität hat das Modell, das am schnellsten reagiert.
  • cost_firstBevorzugt wird das kostengünstigste Modell.
  • balancedAbwägung von Geschwindigkeit und Kosten.
• Beispiel:

  response = LLM_Wrapper.generate(
  model_name="gpt4o_mini",
  prompt="你好",
  mode="cost_first"
  )
  

5. pareto-optimale Wahlmöglichkeiten

• Wählen Sie aus mehreren Modellen das optimale Ergebnis aus:

  response = LLM_Wrapper.generate_fromTHEbest(
  model_list=["gpt4o_mini", "claude35_sonnet", "gemini15_pro"],
  prompt="复杂推理任务"
  )
  

• Das System wählt automatisch das beste Modell auf der Grundlage von Reaktionszeit und Kosten aus.

6. die Gesundheitsüberwachung und -protokollierung

• Prüfen Sie den Gesundheitszustand des Dienstes:
  • Interviews http://localhost:8001/check_healthy Überprüfen Sie den Status der Gesundheitsvorsorge.
  • Interviews http://localhost:8002/check_healthy Überprüfen Sie den Status des API-Schlüsselverwaltungsdienstes.
• Logbuch ansehen:

  docker-compose logs -f airouter-health-check
  tail -f health_check.log
  

caveat

• Stellen Sie sicher, dass der API-Schlüssel gültig ist; ein fehlerhafter Schlüssel führt zum Scheitern der Aufgabe.
• Bei der Bereitstellung von Docker muss sichergestellt werden, dass die Ports (8001, 8002) nicht belegt sind.
• Prüfen Sie das GitHub-Repository regelmäßig auf Updates für die neuesten Funktionen und Fehlerbehebungen.
• Datenbank-Passwort (DB_PASSWORD) ist erforderlich, und sein Fehlen führt zu einem Fehlstart.

Anwendungsszenario

1. Multimodell-Aufgabenverteilung
   Entwickler müssen mehrere LLMs (z. B. OpenAI, Anthropic) gleichzeitig verwenden, um die Aufgabe zu erledigen. AIRouter kann die Aufgabe über eine einheitliche Schnittstelle verteilen und automatisch das optimale Modell auswählen, um Entwicklungszeit zu sparen.
2. Kostensensible Projekte
   Bei einem begrenzten Budget gibt die Kostenoptimierungsfunktion von AIRouter preisgünstigen Modellen für Start-ups oder einzelne Entwickler den Vorzug.
3. Entwicklung multimodaler Anwendungen
   Bei der Entwicklung von Bildbeschreibungen oder multimodalen Chat-Anwendungen unterstützt AIRouter sowohl Text- als auch Bildeingaben, um den Entwicklungsprozess zu vereinfachen.
4. automatisierter Betrieb und Wartung (O&M)
   Ops-Teams können stabile KI-Dienste mit weniger manuellen Eingriffen durch Funktionen zur Zustandsüberwachung und Lastverteilung aufbauen.

QA

1. Welche LLM-Anbieter werden von AIRouter unterstützt?
   Unterstützung für OpenRouter, DeepInfra, DeerAPI, TogetherAI, Google, OpenAI, Anthropic und viele andere Anbieter, mit einer spezifischen Liste der Unterstützung in der ew_config/source.py Ansicht.
2. Wie wählt man das optimale Modell?
   ausnutzen generate_fromTHEbest Methode wählt das System das beste Modell auf der Grundlage eines Pareto-optimalen Algorithmus aus, der Reaktionszeit, Kosten und Erfolgsquote kombiniert.
3. Was ist der Unterschied zwischen der Docker-Bereitstellung und der manuellen Bereitstellung?
   Die Docker-Bereitstellung vereinfacht die Umgebungskonfiguration durch Containerisierung und eignet sich für Produktionsumgebungen; die manuelle Bereitstellung erfordert die Installation der Abhängigkeiten nacheinander und eignet sich für die Entwicklung und Fehlersuche.
4. Wie gehe ich mit dem Ausfall des API-Schlüssels um?
   Das Schlüsselverwaltungssystem von AIRouter erkennt automatisch ungültige Schlüssel und wechselt zu einem verfügbaren Schlüssel. api_keys_local.py Konfigurieren Sie mehrere gültige Schlüssel in der