AgentScope - Une plateforme de développement multi-agents flexible et puissante

Aperçu du projet

AgentScope est une plateforme multi-agents innovante, conçue spécifiquement pour les développeurs afin de construire des applications multi-agents basées sur de grands modèles de langage (LLM). La plateforme utilise l'échange de messages comme mécanisme de communication central, réduisant considérablement la barrière au développement et à la compréhension.

Adresse GitHub : https://github.com/agentscope-ai/agentscope

Caractéristiques principales

1. Principes de conception axés sur le développeur

• Priorité à la transparence : Entièrement transparent pour les développeurs, y compris l'ingénierie des invites, les appels d'API, la construction d'agents, l'orchestration de flux de travail, etc., tous visibles et contrôlables.
• Contrôle en temps réel : Possibilité d'interrompre un agent à tout moment et de personnaliser la méthode de traitement.
• Indépendance du modèle : Une seule programmation, compatible avec tous les modèles.
• Construction d'agents de type LEGO : Tous les composants sont modulaires et indépendants.

2. Conception orientée multi-agents

• Passage de messages explicite : Conçu spécifiquement pour les systèmes multi-agents, prenant en charge le passage de messages explicite et l'orchestration de flux de travail.
• Pas d'encapsulation profonde : Évite les encapsulations complexes, maintenant la lisibilité et la maintenabilité du code.
• Hautement personnalisable : Les outils, les invites, les agents, les flux de travail, les bibliothèques tierces et la visualisation sont tous personnalisables.

3. Mécanismes de tolérance aux pannes robustes

AgentScope offre des mécanismes de tolérance aux pannes intégrés et personnalisables, ainsi qu'un support au niveau du système pour gérer et utiliser les données multimodales, les outils et les connaissances externes. Cela inclut :

• Mécanisme de réessai au niveau du service pour assurer la fiabilité de l'API.
• Outils de correction basés sur des règles pour gérer les problèmes de format dans les réponses des LLM.
• Configuration de tolérance aux pannes personnalisable (parse_func, fault_handler, max_retries, etc.).
• Système de journalisation dédié aux applications multi-agents.

4. Prise en charge de l'architecture distribuée

• Framework distribué basé sur les acteurs : Prend en charge une conversion facile entre les déploiements locaux et distribués.
• Optimisation parallèle automatique : Permet une optimisation parallèle sans effort supplémentaire.
• Prise en charge de simulations à grande échelle : Capable de simuler 1 million d'agents sur 4 appareils.

Nouvelles fonctionnalités d'AgentScope 1.0

Prise en charge de l'exécution asynchrone

• Adopte pleinement le mode d'exécution asynchrone.
• Offre de nombreuses nouvelles fonctionnalités et améliorations.

Fonctionnalités des modules principaux

Module	Fonctionnalité	Description
Model	Prise en charge des appels asynchrones	Prend en charge les appels asynchrones pour divers LLM
Tool	Intégration d'outils	Bibliothèque riche de fonctions d'outils
MCP	Protocole de contrôle de modèle	Prend en charge l'intégration du protocole de contrôle de modèle
Tracing	Surveillance du traçage	Traçage et visualisation de l'exécution de l'application
Memory	Mémoire à long terme	Gestion de la mémoire à long terme des agents
Session	Gestion de session	Gestion de l'état et des sessions
Evaluation	Système d'évaluation	Évaluation des performances des agents
Prompt Formatter	Formatage des invites	Outil de formatage intelligent des invites

Architecture technique

Mécanisme d'échange de messages

AgentScope utilise un mécanisme de communication basé sur les messages :

from agentscope.message import Msg


message_from_alice = Msg("Alice", "Hi!")
message_with_media = Msg("Bob", "What about this picture?", url="/path/to/picture.jpg")

Création d'agents

from agentscope.agent import ReActAgent, UserAgent
from agentscope.model import DashScopeChatModel
from agentscope.formatter import DashScopeChatFormatter
from agentscope.memory import InMemoryMemory
from agentscope.tool import Toolkit, execute_python_code

import os, asyncio

async def main():
    toolkit = Toolkit()
    toolkit.register_tool_function(execute_python_code)
    
    agent = ReActAgent(
        name="Friday",
        sys_prompt="You're a helpful assistant named Friday.",
        model=DashScopeChatModel(
            model_name="qwen-max",
            api_key=os.environ["DASHSCOPE_API_KEY"],
            stream=True,
        ),
        memory=InMemoryMemory(),
        formatter=DashScopeChatFormatter(),
        toolkit=toolkit,
    )
    
    user = UserAgent(name="user")
    
    msg = None
    while True:
        msg = await agent(msg)
        msg = await user(msg)
        if msg.get_text_content() == "exit":
            break

asyncio.run(main())

Pipelines et flux de travail

from agentscope.pipeline import MsgHub, sequential_pipeline
from agentscope.message import Msg

async def multi_agent_conversation():
 
    agent1 = ...
    agent2 = ...
    agent3 = ...
    
   
    pipeline = sequential_pipeline([agent1, agent2, agent3])
    result = await pipeline(initial_message)

Intégration du MCP (Protocole de Contrôle de Modèle)

from agentscope.mcp import HttpStatelessClient
from agentscope.tool import Toolkit
import os

async def fine_grained_mcp_control():

    client = HttpStatelessClient(
        name="gaode_mcp",
        transport="streamable_http",
        url=f"https://mcp.amap.com/mcp?key={os.environ['GAODE_API_KEY']}",
    )
    
  
    func = await client.get_callable_function(func_name="maps_geo")
    

    await func(address="Tiananmen Square", city="Beijing")
    

    toolkit = Toolkit()
    toolkit.register_tool_function(func)

Prise en charge des données multimodales

AgentScope adopte une stratégie de chargement paresseux, découplant le transfert et le stockage des données multimodales en fournissant des propriétés unifiées basées sur des URL dans les messages. Prend en charge :

• Traitement des données texte, image, audio, vidéo.
• Référencement des données basé sur des URL.
• Mécanisme de chargement à la demande.

Écosystème d'outils et de services

Fonctionnalités de service intégrées

• Exécution de code Python
• Recherche Web
• Opérations de fichiers
• Intégration de connaissances externes

Prise en charge du RAG (Génération Augmentée par Récupération)

• Module de traitement des connaissances de bout en bout.
• Système de récupération hautement configurable.
• Composants de traitement des connaissances partageables.

Installation et utilisation

Configuration requise

• Python 3.10 ou version ultérieure

Méthodes d'installation

Installation depuis la source (recommandé)

git clone -b main https://github.com/agentscope-ai/agentscope.git


cd agentscope
pip install -e .

Installation depuis PyPI

pip install agentscope

AgentScope Studio

npm install -g @agentscope/studio
as_studio

Prise en charge des modèles

AgentScope prend en charge une large gamme de grands modèles de langage :

API Cloud

• Série OpenAI GPT
• DashScope (Alibaba Cloud)
• Google Gemini
• ZhipuAI
• API LiteLLM

Déploiement local

• Ollama
• Flask + Transformers/ModelScope
• FastChat
• vLLM

Scénarios d'application

Simulation à grande échelle

• Simulation de marchés financiers
• Modélisation de la planification urbaine
• Analyse de l'efficacité des politiques
• Recherche sur les comportements sociaux

Tâches collaboratives

• Simulation d'équipes de développement logiciel
• Systèmes de dialogue multi-tours
• Résolution de problèmes complexes
• Traitement collaboratif des connaissances

Applications d'entreprise

• Automatisation du service client
• Optimisation des processus métier
• Support intelligent à la décision
• Modélisation de la gestion des risques

Communauté et support

• Documentation officielle : https://doc.agentscope.io/
• Dépôt GitHub : https://github.com/agentscope-ai/agentscope
• Paquet PyPI : https://pypi.org/project/agentscope/
• Tutoriels et exemples : Documentation complète des tutoriels et nombreux exemples de code.

AgentScope représente une avancée majeure dans le développement de systèmes multi-agents, offrant aux chercheurs et aux développeurs une plateforme puissante, flexible et facile à utiliser pour exploiter pleinement le potentiel des agents intelligents.