Guide de l'IA agentique : commencez votre parcours de création d'agents d'IA

Apprenez les bases de la création d'agents d'IA. Découvrez les outils et les techniques nécessaires pour concevoir et mettre en œuvre ces systèmes intelligents.

L'industrie de l'IA connaît des développements rapides. C'est à la fois impressionnant et souvent déroutant.

J'ai étudié, appris et construit mes bases dans ce domaine de la science des données parce que je crois que l'avenir de la science des données est intimement lié au développement de l'IA générative.

Il semble que c'était hier que j'ai construit mon premier agent d'IA, et deux semaines plus tard, il y avait plusieurs paquets Python à choisir, sans parler des options sans code qui obtiennent de très bons résultats, comme n8n.

De simples modèles capables de discuter avec nous à un tsunami d'agents d'IA omniprésents, recherchant sur Internet, manipulant des fichiers et exécutant des projets entiers de science des données (de l'exploration initiale des données à la modélisation et à l'évaluation), tout cela s'est produit en quelques années seulement.

Quoi ?

En voyant tout cela, ma pensée a été : « Je dois m'y joindre le plus tôt possible ». Après tout, il vaut mieux surfer sur la vague que de se faire avaler.

C'est pourquoi j'ai décidé de commencer cette série de publications où je prévois de passer des bases à la construction de notre premier agent d'IA, jusqu'à des concepts plus complexes.

Assez parlé, lançons-nous.

Bases des agents d'IA

Un agent d'IA est créé lorsque nous donnons à un grand modèle de langage (LLM) la capacité d'interagir avec des outils et d'effectuer des actions utiles pour nous. Au lieu d'être simplement un chatbot, il peut désormais programmer des rendez-vous, s'occuper de notre calendrier, rechercher sur Internet, rédiger des publications sur les réseaux sociaux, et la liste est longue… Cette transformation en fait un assistant numérique complet.

Les agents basés sur l'IA peuvent faire des choses utiles, pas seulement discuter.

Mais comment pouvons-nous donner ce pouvoir à un LLM ?

La réponse simple est d'utiliser une API pour interagir avec le LLM. Il existe de nombreux paquets Python pour cela à l'heure actuelle. Si vous suivez mon blog, vous verrez que j'ai déjà expérimenté deux paquets pour créer des agents : Langchain, Agno (anciennement PhiData) et CrewAI, par exemple. Pour cette série, je vais m'en tenir à Agno [1].

Tout d'abord, configurez un environnement virtuel en utilisant uv, Anaconda ou le gestionnaire d'environnement que vous préférez. Ensuite, installez les paquets.

# Agno AI
pip install agno

# module to interact with Gemini
pip install google-generativeai

# Install these other packages that will be needed throughout the tutorial
 pip install agno groq lancedb sentence-transformers tantivy youtube-transcript-api

Remarque rapide avant de continuer. N'oubliez pas d'obtenir une clé API Google Gemini [2].

Créer un agent simple est très facile. Tous les paquets sont très similaires. Ils ont une classe Agent ou quelque chose de similaire qui nous permet de spécifier un modèle et de commencer à interagir avec le LLM que nous choisissons. Voici les principaux composants de cette classe :

model : la connexion au LLM. Ici, nous choisirons entre OpenAI, Gemini, Llama, Deepseek, etc.
description : cet argument nous permet de décrire le comportement de l'agent. Ceci est ajouté à system_message, qui est un argument similaire.
instructions : J'aime penser à l'agent comme à un employé ou un assistant que nous gérons. Afin d'accomplir une tâche, nous devons donner des instructions sur ce qu'il faut faire. Ici, vous pouvez le faire.
expected_output : Ici, nous pouvons donner des instructions sur les sorties attendues.
tools : C'est ce qui transforme le LLM en agent, lui permettant d'interagir avec le monde réel en utilisant ces outils.

Maintenant, créons un agent simple qui n'a pas d'outils, mais qui servira à construire notre intuition sur la structure du code.

# Imports
from agno.agent import Agent
from agno.models.google import Gemini
import os

# Create agent
agent = Agent(
    model= Gemini(id="gemini-1.5-flash",
                  api_key = os.environ.get("GEMINI_API_KEY")),
    description= "An assistant agent",
    instructions= ["Be sucint. Answer in a maximum of 2 sentences."],
    markdown= True
    )

# Run agent
response = agent.run("What's the weather like in NYC in May?")

# Print response
print(response.content)

############ Sortie ###############

Attendez-vous à des températures douces à New York en mai, généralement entre le début des années 50 et le milieu des années 70 Fahrenheit. Il y a une possibilité de pluie, il est donc conseillé de porter des vêtements superposés et un parapluie.

C'est super. Nous utilisons le modèle Gemini 1.5. Remarquez comment il répond en fonction des données sur lesquelles il a été formé. Si nous lui demandons de nous dire le temps qu'il fait aujourd'hui, nous verrons une réponse indiquant qu'il ne peut pas accéder à Internet.

Explorons les arguments instructions et expected_output. Nous voulons maintenant un tableau avec le mois, la saison et la température moyenne pour la ville de New York (NYC).

# Imports
from agno.agent import Agent
from agno.models.google import Gemini
import os

# Create agent
agent = Agent(
    model= Gemini(id="gemini-1.5-flash",
                  api_key = os.environ.get("GEMINI_API_KEY")),
    description= "An assistant agent",
    instructions= ["Be sucint. Return a markdown table"],
    expected_output= "A table with month, season and average temperature",	
    markdown= True
    )

# Run agent
response = agent.run("What's the weather like in NYC for each month of the year?")

# Print response
print(response.content)

Et voici le résultat.

Mois	Saison	Température moyenne (°F)
January	Hiver	32
February	Hiver	35
March	Printemps	44
April	Printemps	54
May	Printemps	63
June	Été	72
July	Été	77
August	Été	76
September	Automne	70
October	Automne	58
November	Automne	48
December	Hiver	37

Les outils

Les réponses précédentes sont bonnes, mais nous ne voulons naturellement pas utiliser de grands modèles linguistiques (LLM) puissants pour jouer avec un chatbot ou pour nous donner des nouvelles obsolètes, n'est-ce pas ?

Nous voulons qu'ils soient un pont vers l'automatisation, la productivité et la connaissance. Par conséquent, les outils ajouteront des capacités à nos agents d'IA, construisant ainsi le pont avec le monde réel. Les exemples courants d'outils d'agent incluent : la recherche sur le Web, l'exécution de SQL, l'envoi d'e-mails ou l'appel d'API.

Mais plus que cela, nous pouvons créer des capacités personnalisées pour nos agents en utilisant n'importe quelle fonction Python comme outil, ce qui ouvre de vastes possibilités d'intégration avec différents systèmes et processus.

Les outils sont des fonctions qu'un agent peut exécuter pour accomplir des tâches.

En termes de code, l'ajout d'un outil à l'agent n'est qu'une question d'utilisation de l'argument tools dans la classe Agent.

Imaginez une entreprise individuelle (une entreprise unipersonnelle) dans le domaine de la santé qui souhaite automatiser sa création de contenu. Cette personne publie chaque jour des conseils sur les habitudes saines. Je sais pertinemment que la création de contenu n'est pas aussi simple qu'il n'y paraît. Elle exige de la créativité, de la recherche et des compétences en rédaction publicitaire. Par conséquent, s'il était possible d'automatiser cela, ou au moins une partie de cela, cela permettrait de gagner du temps.

Nous écrivons donc ce code pour créer un agent très simple qui peut créer une simple publication Instagram et l'enregistrer dans un fichier Markdown pour révision. Nous avons réduit le processus de réflexion > recherche > écriture > révision > publication à révision > publication.

# Imports
import os
from agno.agent import Agent
from agno.models.google import Gemini
from agno.tools.file import FileTools

# Create agent
agent = Agent(
    model= Gemini(id="gemini-1.5-flash",
                  api_key = os.environ.get("GEMINI_API_KEY")),
                  description= "You are a social media marketer specialized in creating engaging content.",
                  tools=[FileTools(
                      read_files=True, 
                      save_files=True
                      )],
                  show_tool_calls=True)


# Writing and saving a file
agent.print_response("""Write a short post for instagram with tips and tricks
                        that positions me as an authority in healthy eating 
                        and save it to a file named 'post.txt'.""",
                     markdown=True)

Par conséquent, nous avons ce qui suit.

Libérez votre énergie positive en mangeant sainement :

1. Donnez la priorité aux aliments complets : mangez beaucoup de fruits, de légumes, de protéines maigres et de grains entiers. Ils sont riches en nutriments et vous donnent une sensation de satiété et d'énergie.

2. Mangez en pleine conscience : soyez attentif aux signaux de faim et de satiété de votre corps.Évitez les distractions lorsque vous mangez.

3. Buvez beaucoup d'eau : l'eau est essentielle à la digestion, aux niveaux d'énergie et à la santé globale.

4. Ne vous privez pas : autorisez-vous quelques douceurs de temps en temps.La privation peut entraîner une suralimentation plus tard. Profitez de tout avec modération !

5. Planifiez à l'avance : préparez vos repas ou vos collations à l'avance pour éviter de prendre des décisions malsaines.

#mangersain #modedeviesain #nutrition #amoureuxdelagastronomie #santéetbienêtre #conseilsdesanté #mangerpropre #pertedepoids #recettessaines #conseilsdenutrition #santéimmédiate #alimentssains #mangerenpleineconscience #voyagesanté #entraîneurdesanté

Bien sûr, nous pourrions rendre la tâche plus complexe en créant un équipage avec d'autres agents pour rechercher du contenu sur une liste de sites Web, un vérificateur de contenu et un réviseur, et un autre pour créer une image pour la publication. Mais je pense que vous avez compris l'idée générale de la façon d'ajouter des tool à Agent.

Un autre type d'outil que nous pouvons ajouter est un outil de fonction. Nous pouvons utiliser une fonction Python comme outil pour le grand modèle linguistique (LLM). N'oubliez pas d'ajouter des indications de type comme video_id:str, afin que le modèle sache ce qu'il doit utiliser comme entrée pour la fonction. Sinon, vous risquez de voir une erreur.

Voyons brièvement comment cela fonctionne.

Nous voulons maintenant que notre agent soit capable d'obtenir une vidéo spécifique sur YouTube et de la résumer. Pour effectuer une telle tâche, nous créons simplement une fonction qui télécharge la transcription de la vidéo de YT et la transmet au modèle pour qu'il la résume.

# Imports
import os
from agno.agent import Agent
from agno.models.google import Gemini
from youtube_transcript_api import YouTubeTranscriptApi

# Get YT transcript
def get_yt_transcript(video_id:str) -> str:
      
    """
    Use this function to get the transcript from a YouTube video using the video id.

    Parameters
    ----------
    video_id : str
        The id of the YouTube video.
    Returns
    -------
    str
        The transcript of the video.
    """

    # Instantiate
    ytt_api = YouTubeTranscriptApi()
    # Fetch
    yt = ytt_api.fetch(video_id)
    # Return
    return ''.join([line.text for line in yt])


# Create agent
agent = Agent(
    model= Gemini(id="gemini-1.5-flash",
                  api_key = os.environ.get("GEMINI_API_KEY")),
                  description= "You are an assistant that summarizes YouTube videos.",
                  tools=[get_yt_transcript],
                  expected_output= "A summary of the video with the 5 main points and 2 questions for me to test my understanding.",
                  markdown=True,
                  show_tool_calls=True)


# Run agent
agent.print_response("""Summarize the text of the video with the id 'hrZSfMly_Ck' """,
                     markdown=True)

Ensuite, vous obtenez un résultat.

Agents dotés de capacités de raisonnement

Une autre option intéressante offerte par le package Agno est la possibilité de créer des agents capables d'analyser la situation avant de répondre à une question. C'est l'outil de raisonnement. Consultez Types d'agents d'IA et leurs utilisations : explication détaillée.

Nous allons créer un agent de raisonnement en utilisant le modèle Qwen-qwq-32b d'Alibaba. Notez que la seule différence ici, outre le modèle, est que nous ajoutons l'outil ReasoningTools(). Cet outil permet à l'agent de raisonner logiquement avant de fournir des réponses.

La propriété adding_instructions=True signifie fournir à l'agent des instructions détaillées, ce qui améliore la fiabilité et la précision de son utilisation de l'outil. Tandis que l'attribution de cette propriété à False oblige l'agent à s'appuyer sur son propre raisonnement, ce qui peut être plus sujet aux erreurs. Cela permet d'évaluer les capacités du modèle de manière indépendante.

# Imports
import os
from agno.agent import Agent
from agno.models.groq import Groq
from agno.tools.reasoning import ReasoningTools


# Create agent with reasoning
agent = Agent(
    model= Groq(id="qwen-qwq-32b",
                  api_key = os.environ.get("GROQ_API_KEY")),
                  description= "You are an experienced math teacher.",
                  tools=[ReasoningTools(add_instructions=True)],
                  show_tool_calls=True)


# Writing and saving a file
agent.print_response("""Explain the concept of sin and cosine in simple terms.""",
                     stream=True,
                     show_full_reasoning=True,
                     markdown=True)

Voici les sorties.

Agent doté de connaissances

C'est le moyen le plus simple de créer un système de récupération augmentée par la génération (RAG). Grâce à cette fonctionnalité, vous pouvez diriger l'agent vers un site Web ou une liste de sites Web, et il ajoutera le contenu à une base de données vectorielle. Ensuite, le contenu devient consultable. Et lorsqu'on le lui demande, l'agent peut utiliser le contenu dans le cadre de la réponse. Cette technique améliore la précision et la fiabilité des réponses de l'IA.

Dans cet exemple simple, j'ai ajouté une seule page de mon site Web et j'ai demandé à l'agent quels étaient les livres qui y étaient répertoriés. Cela montre comment l'agent peut accéder aux informations et les utiliser.

# Imports
import os
from agno.agent import Agent
from agno.models.google import Gemini
from agno.knowledge.url import UrlKnowledge
from agno.vectordb.lancedb import LanceDb, SearchType
from agno.embedder.sentence_transformer import SentenceTransformerEmbedder

# Load webpage to the knowledge base
agent_knowledge = UrlKnowledge(
    urls=["https://gustavorsantos.me/?page_id=47"],
    vector_db=LanceDb(
        uri="tmp/lancedb",
        table_name="projects",
        search_type=SearchType.hybrid,
        # Use Sentence Transformer for embeddings
        embedder=SentenceTransformerEmbedder(),
    ),
)

# Create agent
agent = Agent(
    model=Gemini(id="gemini-2.0-flash", api_key=os.environ.get("GEMINI_API_KEY")),
    instructions=[
        "Use tables to display data.",
        "Search your knowledge before answering the question.",
        "Only inlcude the content from the agent_knowledge base table 'projects'",
        "Only include the output in your response. No other text.",
    ],
    knowledge=agent_knowledge,
    add_datetime_to_instructions=True,
    markdown=True,
)

if __name__ == "__main__":
    # Load the knowledge base, you can comment out after first run
    # Set recreate to True to recreate the knowledge base if needed
    agent.knowledge.load(recreate=False)
    agent.print_response(
        "What are the two books listed in the 'agent_knowledge'",
        stream=True,
        show_full_reasoning=True,
        stream_intermediate_steps=True,
    )

L'agent doté de mémoire

Le dernier type que nous aborderons dans cet article est l'agent doté de mémoire, un concept fondamental dans le domaine des agents d'IA.

Ce type d'agent a la capacité de stocker et de récupérer des informations relatives aux utilisateurs à partir d'interactions antérieures, ce qui lui permet de comprendre les préférences des utilisateurs et de personnaliser ses réponses. Cette mémoire rend l'agent plus efficace lors des interactions ultérieures.

Voyons cet exemple où je vais dire certaines choses à l'agent et demander des recommandations basées sur cette interaction. Cela montre comment l'agent doté de mémoire peut améliorer l'expérience utilisateur.

# imports
import os
from agno.agent import Agent
from agno.memory.v2.db.sqlite import SqliteMemoryDb
from agno.memory.v2.memory import Memory
from agno.models.google import Gemini
from rich.pretty import pprint

# User Name
user_id = "data_scientist"

# Creating a memory database
memory = Memory(
    db=SqliteMemoryDb(table_name="memory", 
                      db_file="tmp/memory.db"),
    model=Gemini(id="gemini-2.0-flash", 
                 api_key=os.environ.get("GEMINI_API_KEY"))
                 )

# Clear the memory before start
memory.clear()

# Create the agent
agent = Agent(
    model=Gemini(id="gemini-2.0-flash", api_key=os.environ.get("GEMINI_API_KEY")),
    user_id=user_id,
    memory=memory,
    # Enable the Agent to dynamically create and manage user memories
    enable_agentic_memory=True,
    add_datetime_to_instructions=True,
    markdown=True,
)


# Run the code
if __name__ == "__main__":
    agent.print_response("My name is Gustavo and I am a Data Scientist learning about AI Agents.")
    memories = memory.get_user_memories(user_id=user_id)
    print(f"Memories about {user_id}:")
    pprint(memories)
    agent.print_response("What topic should I study about?")
    agent.print_response("I write articles for Towards Data Science.")
    print(f"Memories about {user_id}:")
    pprint(memories)
    agent.print_response("Where should I post my next article?")

Ainsi, nous concluons ce premier article sur les agents d'IA. Nous espérons que cela vous a donné un aperçu utile des différents types d'agents d'IA.

Avant de partir

Cet article contient beaucoup d'informations. Nous avons franchi la première étape de l'échelle d'apprentissage des agents d'IA. Je sais que cela peut être déroutant, car il y a tellement d'informations disponibles qu'il est difficile de savoir par où commencer et quoi étudier.

Ma suggestion est de suivre le même chemin que moi. Une étape à la fois, choisissez seulement quelques packages comme Agno et CrewAI, approfondissez-les et apprenez à créer des agents plus complexes à chaque fois. Cette approche progressive est la meilleure pour assimiler les concepts complexes de l'IA.

Dans cet article, nous sommes partis de zéro, nous avons appris à interagir simplement avec un grand modèle linguistique (LLM), jusqu'à la création d'agents avec mémoire, ou même la création d'un simple système de récupération augmentée (RAG) pour un agent d'IA. Ces compétences de base sont essentielles pour comprendre le fonctionnement des agents d'IA.

Il est clair qu'il y a beaucoup plus de choses que vous pouvez faire avec un seul agent. Consultez la référence [4] pour des exemples avancés.

Avec ces compétences simples, assurez-vous que vous êtes en avance sur beaucoup de gens, et il y a beaucoup de choses que vous pouvez déjà faire. Utilisez simplement votre créativité, et pourquoi pas ? Demandez l'aide d'un grand modèle linguistique pour construire quelque chose de formidable ! Utilisez les outils d'IA pour améliorer vos capacités créatives.

Dans le prochain article, nous en apprendrons davantage sur les agents d'IA et leur évaluation. Restez à l'écoute !