Guide de l'IA auto-actionnée : commencez votre parcours vers la création d'agents IA

Apprenez les bases de la création d’agents IA. Découvrez les outils et techniques nécessaires à la conception et à la mise en œuvre de ces systèmes intelligents.

Suivez-nous et ajoutez-nous à vos sources favorites sur Google.

L’industrie de l’intelligence artificielle connaît des développements rapides. C'est impressionnant et souvent déroutant.

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

J’ai l’impression que c’était hier que j’ai construit mon premier agent d’IA , et deux semaines plus tard, il y avait tellement de packages Python parmi lesquels choisir, sans parler des options sans code qui donnent de très bons résultats, comme n8n.

Des simples modèles capables de converser avec nous à un tsunami d'agents d'IA omniprésents, parcourant Internet, gérant des fichiers et exécutant des projets complets 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.

ماذا؟

En voyant tout cela, je me suis dit : « Je dois m’inscrire au plus vite . » Après tout, il vaut mieux surfer sur la vague que d’être emporté.

C'est pour cette raison que j'ai décidé de lancer cette série d'articles dans lesquels je prévois de passer des bases à la construction de notre premier agent d'IA, jusqu'à des concepts plus complexes.

Assez parlé, allons-y.

Notions de base sur les agents IA

Un agent 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 qui nous sont utiles. Au lieu d’être simplement un chatbot, il peut désormais planifier des rendez-vous, gérer 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 à part entière.

Les agents dotés d’IA peuvent faire des choses utiles, pas seulement discuter.

Mais comment donner ce pouvoir à un grand modèle de langage (LLM) ?

La réponse simple est d’utiliser une API pour interagir avec le grand modèle de langage. Il existe aujourd'hui de nombreux packages Python pour cela. Si vous suivez mon blog, vous verrez que j'ai déjà expérimenté quelques packages pour créer des agents : Langchain, Agno (anciennement Phidata) et CrewAI, par exemple. Pour cette série, je m'en tiendrai à Agno[1].

Tout d’abord, configurez un environnement virtuel en utilisant uv Ou Anaconda ou votre processeur d'environnement préféré. Ensuite, installez les packages.

# 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

Une petite remarque avant de continuer : n'oubliez pas d'obtenir la clé API Google Gemini [2].

Créer un proxy simple est très simple. Tous les packages sont très similaires. Ils ont une classe. Agent Ou quelque chose de similaire qui nous permet de sélectionner un modèle et de commencer à interagir avec le modèle de langage plus large de notre choix. Voici les principaux composants de cette catégorie :

model:Connectez-vous au grand modèle de langage. Ici, nous choisirons entre OpenAI, Gemini, Llama, Deepseek, etc.
descriptionCe paramètre nous permet de décrire le comportement de l'agent. Ceci est ajouté à system_message, qui est un support similaire.
instructionsJ’aime considérer un 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_outputIci, nous pouvons fournir des instructions sur le résultat attendu.
toolsC'est ce qui fait d'un grand modèle de langage un agent, lui permettant d'interagir avec le monde réel à l'aide de 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)

## ...

À New York, les températures seront douces en mai, oscillant généralement entre 10 et 24 degrés Celsius. Des averses sont possibles ; il est donc conseillé de s’habiller en plusieurs couches et d’utiliser un parapluie.

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

Explorons les médiateurs. 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.

le Mois	Saison	Température moyenne (°F)
Janvier	Hiver	32
Février	Hiver	35
Mars	Printemps	44
Avril	Printemps	54
mai	Printemps	63
Juin	Été	72
Juillet	Été	77
Août	Été	76
Septembre	Automne	70
Octobre	Automne	58
Novembre	Automne	48
Décembre	Hiver	37

Outils

Les réponses ci-dessus sont bonnes, mais bien sûr, nous ne voulons pas utiliser de puissants modèles de langage volumineux (LLM) pour jouer avec un chatbot ou nous raconter de vieilles nouvelles, n'est-ce pas ?

Nous souhaitons en faire un pont vers l'automatisation, la productivité et le partage des connaissances. Ces outils viendront donc enrichir les capacités de nos agents d'IA, établissant ainsi un lien avec le monde réel. Parmi les outils couramment utilisés par les agents, on peut citer la recherche web, l'exécution de requêtes SQL, l'envoi d'e-mails et les appels d'API.

Mais plus que cela, nous pouvons créer des fonctionnalités personnalisées pour nos agents en utilisant n’importe quelle fonction Python comme outil, ouvrant 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, ajouter un widget à un agent est simplement une question d'utilisation du middleware. tools Dans la catégorie Agent.

Imaginez une entreprise individuelle (entreprise unipersonnelle) dans le domaine de la santé et du bien-être qui souhaite automatiser sa création de contenu. Cette personne publie chaque jour des conseils sur les habitudes saines. Je sais pertinemment que créer du contenu n’est pas aussi simple qu’il y paraît. Cela nécessite de la créativité, des compétences en recherche et en rédaction. Donc, si cela peut être automatisé, ou au moins en partie, cela permet de gagner du temps.

Nous écrivons donc ce code pour créer un agent très simple qui peut créer une publication Instagram simple 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)

En conséquence, nous avons ce qui suit.

Libérez votre énergie positive en mangeant sainement :

1. Privilégiez les aliments complets : consommez beaucoup de fruits, de légumes, de protéines maigres et de céréales complètes. Ils sont riches en nutriments et vous procureront 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 pendant les repas.

3. Buvez beaucoup d’eau : l’eau est essentielle à la digestion, au niveau d’énergie et à la santé globale.

4. Ne vous privez pas : accordez-vous quelques douceurs de temps en temps. La privation peut entraîner des excès alimentaires par la suite. Savourez tout avec modération !

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

#AlimentationSaine #ModeDeVieSain #Nutrition #AmiGastronomique #SantéEtBien-Être #ConseilsSanté #AlimentationPropre #PerteDePoids #RecettesSaines #ConseilsNutrition #SantéInstantanée #AlimentationSaine #AlimentationConsciente #ParcoursSanté #CoachSanté

Bien sûr, nous pourrions rendre les choses plus compliquées en créant une équipe avec d'autres agents pour rechercher du contenu dans la liste des sites Web, un vérificateur et un réviseur de contenu, 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 tool إلى Agent.

Un autre type d’outil que nous pouvons ajouter est : Outil outil de fonction. Nous pouvons utiliser une fonction Python pour agir comme un outil pour un grand modèle de langage (LLM). N'oubliez pas d'ajouter des indications de type comme : video_id:str, afin que le modèle sache quoi 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 puisse obtenir une vidéo YouTube spécifique et la résumer. Pour effectuer une telle tâche, nous créons simplement une fonction qui télécharge la transcription vidéo de YT et la transmet au modèle pour résumé.

# 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 la capacité de raisonner

Une autre fonctionnalité remarquable de la suite Agno est la possibilité de créer des agents capables d'analyser une situation avant de répondre à une question. Il s'agit d'un outil d'inférence. Découvrez les différents types d'agents d'IA et leurs applications : une 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 le widget. ReasoningTools(). Cet outil permet à l’agent de réfléchir logiquement avant de fournir des réponses.

Propriété signifie adding_instructions=True Fournir à l'agent des instructions détaillées, améliorant la fiabilité et la précision de son utilisation de l'outil. La définition de cette propriété entraînera : False Forcer l’agent à s’appuyer sur son propre raisonnement, qui peut être plus sujet aux erreurs. Cela permet d’évaluer indépendamment les capacités du modèle.

# 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)

Vous trouverez ci-dessous les résultats.

agent fournissant des connaissances

Cet outil est le moyen le plus simple de créer un système de génération augmentée de récupération (RAG). Avec 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. Après cela, le contenu devient consultable. Lorsque vous y êtes invité, l'agent peut utiliser le contenu dans le cadre de la réponse. Cette technologie améliore la précision et la fiabilité des réponses de l’IA.

Dans cet exemple simple, j'ai ajouté une page de mon site Web et j'ai demandé à l'agent quels livres y étaient répertoriés. Ceci explique 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,
    )

Agent à mémoire activée

Le dernier type que nous aborderons dans cet article est l’agent à mémoire activée, 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 sur les utilisateurs à partir d'interactions précédentes, 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 dans les interactions ultérieures.

Voyons cet exemple où je dirai certaines choses à l'agent et demanderai des recommandations en fonction de cette interaction. Cela démontre comment un 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?")

Ceci conclut notre premier article sur les agents d'intelligence artificielle . Nous espérons qu'il vous a offert un aperçu utile des différents types d'agents d'IA.

قبل المغادرة

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

Je vous suggère de suivre le même chemin que moi. Une étape à la fois, choisissez quelques packages comme Agno et CrewAI, explorez-les et apprenez à créer des agents plus complexes à chaque fois. Cette approche progressive est idéale pour comprendre les concepts complexes de l’IA.

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

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

Grâce à ces compétences simples, vous serez certainement en avance sur beaucoup de gens, et vous pouvez déjà faire beaucoup de choses. Utilisez simplement votre créativité, pourquoi pas ? Demandez à un grand modèle de langage de vous aider à construire quelque chose de génial ! Utilisez des outils d’IA pour améliorer votre créativité.

Dans le prochain article, nous en apprendrons davantage sur les agents IA et leur évaluation. Restez connectés !