Qwen-Agent Projekt – Detaillierte Vorstellung

Projektübersicht

Qwen-Agent ist ein auf dem Qwen-Sprachmodell basierendes Framework zur Entwicklung von intelligenten Agenten, das speziell für die Entwicklung von LLM-Anwendungen mit Fähigkeiten zur Befolgung von Anweisungen, Werkzeugnutzung, Planung und Gedächtnis entwickelt wurde. Das Projekt wird vom Alibaba Qwen-Team entwickelt und gewartet und dient derzeit als Backend-Unterstützung für den Qwen Chat-Service.

Kernfunktionen

1. Unterstützung für multifunktionale Agenten

Browser-Assistent (Browser Assistant): Web-Browsing- und Bedienungsfähigkeiten
Code-Interpreter (Code Interpreter): Ausführung und Analyse von Python-Code
Benutzerdefinierter Assistent (Custom Assistant): Personalisierte Anpassung von intelligenten Agenten
RAG-Retrieval-Augmentation: Dokumenten-Fragen und Wissensabruf
Chrome-Erweiterung: Intelligenter Assistent in Form eines Browser-Plugins

2. Integration fortschrittlicher Technologien

Funktionsaufruf (Function Calling): Unterstützung für Werkzeug- und API-Integration
MCP-Protokollunterstützung: Kompatibilität mit dem Modellkontextprotokoll
Parallele Werkzeugaufrufe: Mehrschrittige, mehrrundige Werkzeugnutzung
Inferenzfähigkeit: Integration von Inferenzmodellen wie QwQ-32B

Neueste Aktualisierungen

18. März 2025: Unterstützung des Feldes reasoning_content, Anpassung der Standardvorlage für Funktionsaufrufe
7. März 2025: Hinzufügung einer QwQ-32B-Werkzeugaufruf-Demo, Unterstützung für parallele und mehrschrittige Aufrufe
3. Dezember 2024: Upgrade der GUI auf Gradio 5, erfordert Python 3.10+
18. September 2024: Hinzufügung einer Qwen2.5-Math-Demo, die die Inferenzfähigkeit der Werkzeugintegration demonstriert

Installationsmethoden

Installation der stabilen Version

pip install -U "qwen-agent[gui,rag,code_interpreter,mcp]"
# Oder minimale Installation
pip install -U qwen-agent

Installation der Entwicklungsversion

git clone https://github.com/QwenLM/Qwen-Agent.git
cd Qwen-Agent
pip install -e ./"[gui,rag,code_interpreter,mcp]"

Optionale Abhängigkeitserklärung

[gui]: Gradio-Unterstützung für die grafische Benutzeroberfläche
[rag]: RAG-Retrieval-Augmentation-Funktion
[code_interpreter]: Code-Interpreter-Funktion
[mcp]: MCP-Protokollunterstützung

Modellservice-Konfiguration

Methode 1: Verwendung des DashScope-Dienstes

llm_cfg = {
    'model': 'qwen-max-latest',
    'model_server': 'dashscope',
    # 'api_key': 'YOUR_DASHSCOPE_API_KEY',
    'generate_cfg': {
        'top_p': 0.8
    }
}

Methode 2: Selbst gehosteter Modellservice

llm_cfg = {
    'model': 'Qwen2.5-7B-Instruct',
    'model_server': 'http://localhost:8000/v1',
    'api_key': 'EMPTY',
}

Kernkomponentenarchitektur

Basiskomponenten

BaseChatModel: LLM-Basisklasse, unterstützt Funktionsaufrufe
BaseTool: Werkzeugbasisklasse, erweiterbar für benutzerdefinierte Funktionen
Agent: Intelligente Agenten-Basisklasse, unterstützt Vererbung und Anpassung

Erweiterte Komponenten

Assistant: Universeller Assistenten-Agent
FnCallAgent: Funktionsaufruf-Agent
ReActChat: Inferenz-Aktions-Dialog-Agent

Beispiele für tatsächliche Anwendungen

Erstellung eines benutzerdefinierten Werkzeug-Agenten

import pprint
import urllib.parse
import json5
from qwen_agent.agents import Assistant
from qwen_agent.tools.base import BaseTool, register_tool
from qwen_agent.utils.output_beautify import typewriter_print

# Schritt 1: Hinzufügen eines benutzerdefinierten Werkzeugs
@register_tool('my_image_gen')
class MyImageGen(BaseTool):
    description = 'KI-Malerei (Bildgenerierung), Eingabe einer Textbeschreibung und Rückgabe der auf Textinformationen basierenden Bild-URL.'
    parameters = [{
        'name': 'prompt',
        'type': 'string',
        'description': 'Detaillierte Beschreibung des gewünschten Bildinhalts, auf Englisch',
        'required': True
    }]
    
    def call(self, params: str, **kwargs) -> str:
        prompt = json5.loads(params)['prompt']
        prompt = urllib.parse.quote(prompt)
        return json5.dumps(
            {'image_url': f'https://image.pollinations.ai/prompt/{prompt}'},
            ensure_ascii=False)

# Schritt 2: Konfiguration des LLM
llm_cfg = {
    'model': 'qwen-max-latest',
    'model_server': 'dashscope',
    'generate_cfg': {
        'top_p': 0.8
    }
}

# Schritt 3: Erstellung des Agenten
system_instruction = '''Nach Erhalt der Anfrage des Benutzers sollten Sie:
- zuerst ein Bild zeichnen und die Bild-URL erhalten,
- dann Code `request.get(image_url)` ausführen, um das Bild herunterzuladen,
- und schließlich eine Bildoperation aus dem gegebenen Dokument auswählen, um das Bild zu verarbeiten.
Bitte zeigen Sie das Bild mit `plt.show()` an.'''

tools = ['my_image_gen', 'code_interpreter']
files = ['./examples/resource/doc.pdf']
bot = Assistant(llm=llm_cfg,
                system_message=system_instruction,
                function_list=tools,
                files=files)

# Schritt 4: Ausführen des Agenten-Chats
messages = []
while True:
    query = input('\nuser query: ')
    messages.append({'role': 'user', 'content': query})
    response = []
    response_plain_text = ''
    print('bot response:')
    for response in bot.run(messages=messages):
        response_plain_text = typewriter_print(response, response_plain_text)
    messages.extend(response)

Starten der Web-UI-Oberfläche

from qwen_agent.gui import WebUI
WebUI(bot).run()

MCP-Protokollintegration

Beispiel für die MCP-Serverkonfiguration

{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-memory"]
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/allowed/files"]
    },
    "sqlite": {
      "command": "uvx",
      "args": [
        "mcp-server-sqlite",
        "--db-path",
        "test.db"
      ]
    }
  }
}

Anforderungen an die Abhängigkeitsumgebung

Node.js (neueste Version)
uv 0.4.18 oder höher
Git
SQLite

RAG-Dokumenten-Fragen-Funktion

Das Projekt bietet eine schnelle RAG-Lösung sowie einen wettbewerbsfähigen Agenten für ultralange Dokumente, der in zwei anspruchsvollen Benchmarks besser abschneidet als native Long-Context-Modelle und in einem Single-Shot-"Nadel im Heuhaufen"-Stresstest mit 1 Million Token Kontext perfekt abschneidet.

BrowserQwen Browser-Assistent

BrowserQwen ist ein auf Qwen-Agent basierender Browser-Assistent, der Web-Browsing-, Bedienungs- und Informationsextraktionsfunktionen bietet.

Technische Merkmale und Vorteile

Modulares Design: Atomare Komponenten, einfach zu erweitern und anzupassen
Unterstützung mehrerer Modelle: Kompatibel mit verschiedenen Versionen der Qwen-Serie
Reichhaltiges Werkzeug-Ökosystem: Integrierte verschiedene praktische Werkzeuge
Flexible Bereitstellung: Unterstützung für Cloud-Dienste und lokale Bereitstellung
Aktive Wartung: Kontinuierliche Aktualisierungen und Funktionserweiterungen

Links zu relevanten Ressourcen

GitHub-Repository: https://github.com/QwenLM/Qwen-Agent
Offizielle Dokumentation: https://qwen.readthedocs.io/
Online-Erlebnis: https://chat.qwen.ai/
Technischer Blog: https://qwenlm.github.io/blog/qwen-agent-2405/
Hugging Face: https://huggingface.co/Qwen
ModelScope: https://modelscope.cn/organization/qwen

Zusammenfassung

Qwen-Agent ist ein leistungsstarkes und einfach zu bedienendes Framework zur Entwicklung von intelligenten Agenten, das Entwicklern eine vollständige Toolchain zum Erstellen komplexer LLM-Anwendungen bietet. Ob einfacher Chatbot oder komplexer multifunktionaler intelligenter Assistent, er kann mit diesem Framework schnell implementiert und bereitgestellt werden.