Au revoir LangChain ! Atomic Agents est en feu !

ressemblerLangChain,CrewAIrépondre en chantantAutoGenCes cadres sont populaires car ils fournissent des abstractions de haut niveau pour la construction de systèmes d'IA. Cependant, de nombreux développeurs, dont je fais partie, ont constaté que ces outils font plus de mal que de bien, ajoutant souvent une complexité et une frustration inutiles au processus de développement.

entrer dansAgents atomiques- Un cadre de travail modulaire et rationalisé conçu pour éliminer les problèmes liés aux outils de développement de l'IA existants. Modèle entrée-processus-sortie (IPO)répondre en chantantatomicitéen proposant une nouvelle approche qui met l'accent sur la simplicité, la flexibilité et le contrôle par le développeur.

Dans cet article, nous allons examiner de plus près pourquoi les agents atomiques ont été créés, le paradigme de programmation qu'ils utilisent et comment ils se distinguent des autres. Découvrez les agents atomiques à l'aide d'échantillons de code et d'exemples concrets, et si vous avez toujours pensé que LangChain était trop compliqué, voici un aperçu de l'ensemble !

Problèmes liés aux cadres d'IA existants

Lorsque j'ai commencé à expérimenter avecLangChainÀ l'époque, j'étais très intéressé par la simplification du développement d'agents d'IA. En réalité, ce n'est pas si simple.

Outre la complexité des classes et des méthodes, les développeurs de LangChain ne semblent pas comprendre les défis pratiques du développement de l'IA, valorisant peut-être davantage l'élégance théorique que la facilité d'utilisation dans le monde réel. L'abstraction excessive ne rend pas seulement le développement plus difficile, elle le rend également opaque.

Illusions magiques dans CrewAI et AutoGen

De même.CrewAIrépondre en chantantAutoGenLes cadres de ce type tentent également de fournir des solutions "magiques" en automatisant des tâches complexes. L'idée de déployer des essaims d'agents d'intelligence artificielle pour tout gérer de manière autonome est tentante, mais dans la pratique, ces outils ne fonctionnent souvent pas correctement la moitié du temps. Dans la pratique, ils promettent trop et ne tiennent pas assez, laissant les développeurs submergés par des comportements imprévisibles et un manque de contrôle.

Ces cadres brouillent les processus sous-jacents, ce qui rend difficile le débogage ou la personnalisation des fonctionnalités. Le résultat est que ces outils sont plus une boîte noire qu'un cadre utile - ce qui n'est pas idéal pour développer des applications qui requièrent fiabilité et maintenabilité.

La fonction de surengagement : questions fréquemment posées

L'un des problèmes récurrents de ces cadres est la tendance àFonction de surengagement. Certaines entreprises et certains outils prétendent offrir des solutions proches de l'AGI (Intelligence Générale Artificielle), mais si vous avez eu une longue carrière dans le domaine de l'IA, vous vous rendrez compte que nous n'en sommes pas encore là. Le battage médiatique conduit souvent à des attentes irréalistes, et lorsque ces outils échouent inévitablement, les développeurs doivent en assumer les conséquences.

Besoin d'une meilleure solution

Après avoir essuyé ces échecs, il nous est apparu clairement que nous avions besoin d'un tel cadre :Élimination de la complexité inutileet des couches d'abstraction :

• Élimination de la complexité inutileet des couches d'abstraction.
• Offrir aux développeurs un contrôle totalsans dissimuler des fonctionnalités essentielles derrière des interfaces opaques.
• Suivre des paradigmes de programmation fiables et éprouvésLa mise en place d'un système de gestion de l'environnement permet d'améliorer la maintenabilité et l'évolutivité de l'infrastructure.
• Conçu par des développeurs, pour des développeurscomprendre les défis pratiques auxquels est confronté le développement de l'IA.

Cette compréhension a conduit àAgents atomiquesLa naissance de.

Introduction aux agents atomiques

Logo des agents atomiques

Agents atomiquesest un framework open source conçu pour être aussi léger, modulaire et composable que possible. Il suit le modèleModèle entrée-traitement-sortie (IPO)répondre en chantantatomicitéen veillant à ce que chaque composant soit à usage unique, réutilisable et interchangeable.

Pourquoi les agents atomiques existent-ils ?

Agents atomiques a été créé pour combler les lacunes des cadres existants. Il vise à

• En fournissant des éléments clairs et gérables.Simplifier le développement de l'intelligence artificielle.
• Élimination de la complexité redondante qui caractérise les autres cadres de travailet des abstractions inutiles.
• Promouvoir la flexibilité et la cohérencece qui permet aux développeurs de se concentrer sur la création d'applications d'IA efficaces plutôt que de s'emmêler les pinceaux avec le cadre lui-même.
• Encourager les bonnes pratiquesLes développeurs sont encouragés à adopter une structure de code modulaire et facile à maintenir.

En adhérant à ces principes, Atomic Agents permet aux développeurs de créer des agents et des applications d'IA qui sont à la fois puissants et faciles à gérer.

Le paradigme de programmation des agents atomiques

Modèle entrée-processus-sortie (IPO)

Au cœur d'Atomic Agents se trouve le système de gestion de l'information de la Commission européenne.Modèle entrée-processus-sortie (IPO)Il s'agit d'un paradigme de programmation de base qui divise la structure d'un programme en trois phases distinctes :

1. EntréeLes données sont transmises par les utilisateurs ou par d'autres systèmes.
2. ProcessusTraitement des données : traitement ou conversion des données.
3. SortieLes données traitées sont présentées sous forme de résultats.

Ce modèle est clair et concis et facilite la compréhension et la gestion du flux de données dans une application.

En ce qui concerne les agents atomiques, cela se traduit par

• Schémas d'entréePydantic : Utiliser Pydantic pour définir la structure des données d'entrée et les règles de validation.
• Composants de transformationAgents et outils qui effectuent des opérations sur les données.
• Schémas de sortieLes résultats sont structurés et validés avant d'être renvoyés.

Atomicité : éléments fonctionnels

atomicitéLe concept consiste à décomposer un système complexe en ses plus petites parties fonctionnelles ou "atomes". Chaque atome

• Avoir une responsabilité uniqueIl est ainsi plus facile à comprendre et à entretenir.
• RéutilisableCela permet d'utiliser les composants dans différentes parties de l'application ou même dans différents projets.
• Peut être combiné avec d'autres composants atomiques pour créer des fonctions plus complexes.

En se concentrant sur des composants atomiques, les agents atomiques facilitent une architecture modulaire pour une flexibilité et une évolutivité accrues.

Fonctionnement des agents atomiques

ingrédient

Dans Atomic Agents, l'agent d'intelligence artificielle se compose de plusieurs éléments clés :

• alerte systèmeDéfinir le comportement et l'objectif de l'agent.
• mode d'entrée: Spécifie la structure attendue des données d'entrée.
• mode de sortie: Définit la structure des données de sortie.
• mémoire vive (RAM)Historique du dialogue : Enregistre l'historique du dialogue ou des informations sur l'état de celui-ci.
• la programmation contextuelleInjecte un contexte dynamique dans l'invite du système au moment de l'exécution.
• artefactFonctions externes ou interfaces d'application disponibles pour l'agent.

Chaque composant est conçu pour être modulaire et interchangeable et suit les principes de la séparation des préoccupations et de la responsabilité unique.

Modularité et composabilité

La modularité est au cœur des agents atomiques. En concevant des composants autonomes et axés sur une tâche unique, les développeurs peuvent

• Changement d'outils ou d'agentssans affecter le reste du système.
• Ajustement des composants individuelstels que les invites ou les modes du système, sans créer d'effets secondaires involontaires.
• En ajustant les modes d'entrée et de sortie, laAgents et outilsL'ensemble est assemblé de manière transparente.

Cette approche modulaire rend non seulement le développement plus facile à gérer, mais améliore également la maintenabilité et l'évolutivité des applications d'IA.

Fournir un contexte : améliorer la flexibilité

la programmation contextuellePermettre aux agents d'inclure des données dynamiques dans les messages-guides du système et d'améliorer les réponses en fonction des informations les plus récentes.

Exemple :

from atomic_agents.lib.components.system_prompt_generator import SystemPromptContextProviderBase

class SearchResultsProvider(SystemPromptContextProviderBase):
def __init__(self, title: str, search_results: List[str]):
super().__init__(title=title)
self.search_results = search_results
def get_info(self) -> str:
return "n".join(self.search_results)
# 向代理注册上下文提供程序
agent.register_context_provider("search_results", search_results_provider)

En injectant des données en temps réel dans le contexte de l'agent, vous pouvez créer des applications d'IA plus dynamiques et plus réactives.

Enchaînement de motifs et d'agents

Atomic Agents simplifie le processus d'enchaînement des agents et des outils en ajustant les modes d'entrée et de sortie.

Exemple : Supposons que vous disposiez d'un agent de génération de requêtes et d'un outil de recherche sur le web. En paramétrant le modèle de sortie de l'agent de génération de requêtes pour qu'il corresponde au modèle d'entrée de l'outil de recherche, vous pouvez les enchaîner directement l'un à l'autre.

from web_search_agent.tools.searxng_search import SearxNGSearchTool

# Initialize the query agent
query_agent = BaseAgent(
BaseAgentConfig(
# ... other configurations ...
output_schema=SearxNGSearchTool.input_schema,  # Align output schema
)
)

Cette conception améliore la réutilisation et la flexibilité, ce qui permet de remplacer facilement les composants ou d'étendre les fonctionnalités.

Raisons pour lesquelles les agents atomiques sont meilleurs que les autres produits

Élimination de la complexité inutile

Contrairement aux frameworks qui introduisent de multiples couches d'abstraction, Atomic Agents reste simple et direct. Chaque composant a un objectif clair et il n'y a pas de magie cachée à découvrir.

• architecture transparenteVous pouvez comprendre parfaitement comment les données circulent dans votre application.
• Débogage facilitéLa complexité réduite facilite l'identification et la résolution des problèmes.
• Courbe d'apprentissage réduiteLes développeurs peuvent démarrer rapidement sans avoir à comprendre des concepts abstraits complexes.

Construit par des développeurs, pour des développeurs

Atomic Agents a été conçu en tenant compte des défis de développement du monde réel. Il utilise des paradigmes de programmation éprouvés et donne la priorité à l'expérience des développeurs.

• Solides bases en programmationLe cadre encourage les meilleures pratiques en suivant le modèle de l'IPO et l'atomicité.
• Flexibilité et contrôleLes développeurs sont libres de personnaliser et d'étendre les composants selon leurs besoins.
• axé sur la communautéLe projet : En tant que projet open source, il invite la communauté des développeurs à contribuer et à collaborer.

Composants autonomes et réutilisables

Chaque partie des agents atomiques peut fonctionner indépendamment, ce qui favorise la réutilisation et la modularité.

• Peut être testé de manière isoléeLes composants peuvent être testés individuellement pour s'assurer de leur fiabilité avant l'intégration.
• Réutilisable d'un projet à l'autreLes composants atomiques peuvent être utilisés dans différentes applications, ce qui permet d'économiser du temps de développement.
• Une maintenance plus facileLa fonction d'isolation réduit l'impact des changements et simplifie les mises à jour.

Construire un agent d'intelligence artificielle simple

Nous construirons un agent d'intelligence artificielle qui répondra aux demandes des utilisateurs et leur posera des questions de suivi.

Étape 1 : Définir des modes d'entrée et de sortie personnalisés

from pydantic import BaseModel, Field from typing import List from atomic_agents.agents.base_agent import BaseIOSchema

class CustomInputSchema(BaseIOSchema):
chat_message: str = Field(..., description="The user's input message.")

class CustomOutputSchema(BaseIOSchema):
chat_message: str = Field(..., description="The agent's response message.")
suggested_questions: List[str] = Field(..., description="Suggested follow-up questions.")

Étape 2 : Mise en place d'alertes système

from atomic_agents.lib.components.system_prompt_generator import SystemPromptGenerator

system_prompt_generator = SystemPromptGenerator(
background=[
"You are a knowledgeable assistant that provides helpful information and suggests follow-up questions."
],
steps=[
"Analyze the user's input to understand the context and intent.",
"Provide a relevant and informative response.",
"Generate 3 suggested follow-up questions."
],
output_instructions=[
"Ensure clarity and conciseness in your response.",
"Conclude with 3 relevant suggested questions."
]
)

Étape 3 : Initialisation de l'agent

from atomic_agents.agents.base_agent import BaseAgent, BaseAgentConfig
import instructor
import openai

# Initialize the agent
agent = BaseAgent(
config=BaseAgentConfig(
client=instructor.from_openai(openai.OpenAI(api_key='YOUR_OPENAI_API_KEY')),
model="gpt-4",
system_prompt_generator=system_prompt_generator,
input_schema=CustomInputSchema,
output_schema=CustomOutputSchema
)
)

Étape 4 : Utilisation de serveurs mandataires

user_input = "Can you explain the benefits of using Atomic Agents?" input_data = CustomInputSchema(chat_message=user_input) response = agent.run(input_data)

print(f"Agent: {response.chat_message}")
print("Suggested questions:")
for question in response.suggested_questions:
print(f"- {question}")

Résultats attendus :

Agent: Atomic Agents simplifies AI development by providing modular, reusable components based on solid programming paradigms like the IPO model and atomicity.
Suggested questions:
- How does Atomic Agents compare to other AI frameworks?
- Can you provide an example of building an agent with Atomic Agents?
- What are the key features of Atomic Agents that enhance productivity?

Outils d'intégration et fournisseurs de contexte

Supposons que nous souhaitions que l'agent effectue une recherche sur le web à partir d'une requête de l'utilisateur.

Étape 1 : Télécharger et installer SearxNGSearchTool

utiliser CLI de l'assembleur atomiqueNous pouvons télécharger l'outil de recherche :

atomic

Sélectionnez SearxNGSearchTool dans le menu et suivez les instructions pour installer les dépendances.

Étape 2 : Intégration des outils de recherche

from web_search_agent.tools.searxng_search import SearxNGSearchTool, SearxNGSearchToolConfig

# 初始化搜索工具
search_tool = SearxNGSearchTool(config=SearxNGSearchToolConfig(base_url="http://localhost:8080"))

Étape 3 : Mise à jour de l'agent pour l'utilisation de l'outil

Nous pouvons modifier l'agent pour qu'il décide quand utiliser l'outil de recherche en fonction des données fournies par l'utilisateur.

from typing import Union

class OrchestratorOutputSchema(BaseModel):
tool: str = Field(..., description="The tool to use: 'search' or 'chat'")
parameters: Union[SearxNGSearchTool.input_schema, CustomInputSchema] = Field(..., description="Parameters for the selected tool.")
# 修改代理逻辑以输出 OrchestratorOutputSchema
# ...
# 执行选定的工具
if response.tool == "search":
search_results = search_tool.run(response.parameters)
# 处理检索结果
else:
# 使用之前的聊天代理
pass

Étape 4 : Utiliser un fournisseur contextuel pour les résultats de recherche

class SearchResultsProvider(SystemPromptContextProviderBase):
    def __init__(self, search_results):
        super().__init__(title="Search Results")
        self.search_results = search_results
def get_info(self) -> str:
return "n".join(self.search_results)
# After obtaining search results
context_provider = SearchResultsProvider(search_results)
agent.register_context_provider("search_results", context_provider)

Grâce à cette intégration, les agents peuvent fournir des réponses basées sur des données de recherche en ligne en temps réel.

CLI de l'assembleur atomique : outils de gestion simples

Les agents atomiques se distinguent par les caractéristiques suivantesCLI de l'assembleur atomiqueIl s'agit d'un outil en ligne de commande qui simplifie la gestion des outils et des agents.

Inspiré par certaines bibliothèques modernes de Tailwind comme shadcn, où au lieu d'installer des composants en tant que dépendances, vous vous les appropriez dans votre propre code source.

Cela signifie qu'au lieu d'installer l'outil comme une dépendance à l'aide de pip, nous allons le copier dans notre projet. Il y a deux façons de procéder :

1. Téléchargez l'outil manuellement, ou copiez/collez le code source depuis le dépôt GitHub d'Atomic Agents et déposez-le dans le fichier atomic-forge dossier.
2. Nous utiliserons le CLI Atomic Assembler pour télécharger l'outil.

Agents atomiques

fonction des touches

• Outils de téléchargement et de gestionLes nouveaux outils : ajoutez facilement de nouveaux outils à vos projets sans avoir à copier manuellement ou à résoudre les dépendances.
• Éviter l'encombrement des dépendancesLes outils de travail : Pour alléger votre projet, n'installez que les outils dont vous avez besoin.
• Outil de modification facileChaque outil est indépendant, avec ses propres tests et sa propre documentation.
• Outils d'accès directSi vous le souhaitez, vous pouvez gérer manuellement les outils en accédant au dossier Tools.

écrire à la fin

Atomic Agents apporte un changement nécessaire dans le domaine du développement de l'IA en donnant la priorité à la simplicité, à la modularité et au contrôle du développeur. En adoptant des paradigmes de programmation fiables tels que le modèle Entrée-Processus-Sortie et l'atomicité, il résout de nombreux problèmes auxquels les développeurs sont confrontés lorsqu'ils utilisent LangChain, CrewAI et AutoGen Les frustrations rencontrées dans les cadres existants tels que la

Avec Atomic Agents, vous pouvez

• Élimination de la complexité inutilequi se concentre sur la création d'applications d'IA efficaces.
• Contrôle totalchaque élément du système.
• Remplacer ou modifier facilement les composantssans interrompre l'ensemble de l'application.
• Tirer parti de la modularité et de la réutilisationAméliorer l'efficacité et la maintenabilité.

Si vous en avez assez de vous débattre avec des cadres trop complexes qui promettent trop et ne tiennent pas assez, il est temps d'essayer Atomic Agents.