Créez des agents LLM plus rapidement avec Datapizza AI

Les organisations investissent de plus en plus dans l’IA à mesure que ces nouveaux outils sont de plus en plus adoptés dans les opérations quotidiennes. Cette vague continue d’innovation alimente la demande de cadres plus efficaces et plus fiables. Suivant cette tendance, Datapizza (la startup derrière la communauté technologique italienne) vient de publier un framework open source pour GenAI avec Python, appelé IA Datapizza.

Lors de la création d’agents basés sur LLM, vous devez choisir un Pile IA:

• Modèle de langage – le cerveau de l’Agent. Le premier grand choix est l’open source (c’est-à-dire Lama, Recherche profonde, Phi) vs payant (c’est-à-dire ChatGPT, Claude, Gémeaux). Ensuite, en fonction du cas d’utilisation, il faut considérer les connaissances LLM : génériques (connaît un peu de tout comme Wikipédia) vs spécifiques à un sujet (c’est-à-dire affinées pour le codage ou la finance).
• Moteur LLM – c’est ce qui gère le modèle linguistique, en répondant aux invites, en déduisant le sens et en créant du texte. Fondamentalement, cela génère de l’intelligence. Les plus utilisés sont OpenAI (ChatGPT), Anthropique (Claude), Google (Gémeaux), et Ollama (exécute des modèles open source localement).
• Cadre d’IA – c’est la couche d’orchestration permettant de créer et de gérer les flux de travail. En d’autres termes, le cadre doit structurer l’intelligence créée par les LLM. À l’heure actuelle, le paysage est dominé par LangChaîne, LLamaIndexet ÉquipageAI. La nouvelle bibliothèque IA Datapizza entre dans cette catégorie et veut être une alternative aux autres frameworks principaux.

Dans cet article, je vais montrer comment utilisez le nouveau framework Datapizza pour créer des agents IA basés sur LLM. Je présenterai du code Python utile qui peut être facilement appliqué dans d’autres cas similaires (il suffit de copier, coller, exécuter) et de parcourir chaque ligne de code avec des commentaires afin que vous puissiez reproduire cet exemple.

Installation

j’utiliserai Ollama comme moteur LLM, car j’aime héberger des modèles localement sur mon ordinateur. C’est la pratique standard pour toutes les entreprises disposant de données sensibles. Garder tout en local donne un contrôle total sur la confidentialité des données, le comportement du modèle et les coûts.

Tout d’abord, vous devez téléchargez Ollama depuis le site Web. Ensuite, choisissez un modèle et exécutez la commande indiquée sur la page pour extraire le LLM. je pars avec d’Alibaba Qwencar il est à la fois intelligent et léger (ollama run qwen3).

IA Datapizza prend en charge tous les principaux moteurs LLM. Nous pouvons terminer la configuration en exécutant les commandes suivantes :

pip install datapizza-ai
pip install datapizza-ai-clients-openai-like

Comme indiqué dans le documentation officiellenous pouvons tester rapidement notre pile d’IA en appelant le modèle avec une simple invite et en posant une question. L’objet OpenAILikeClient() C’est ainsi que vous vous connectez à l’API Ollama, qui est généralement hébergée sur la même URL localhost.

from datapizza.clients.openai_like import OpenAILikeClient

llm = "qwen3"

prompt = '''
You are an intelligent assistant, provide the best possible answer to user's request. 
''' 

ollama = OpenAILikeClient(api_key="", model=llm, system_prompt=prompt, base_url="http://localhost:11434/v1")

q = '''
what time is it?
'''

llm_res = ollama.invoke(q)
print(llm_res.text)

Chatbot

Une autre façon de tester les capacités du LLM consiste à créer un simple chatbot et à mener une conversation. Pour ce faire, à chaque interaction, nous devons stocker l’historique des discussions et le renvoyer au modèle, en précisant ce qui a été dit par qui. Le framework Datapizza a déjà un intégré système de mémoire.

from datapizza.memory import Memory from datapizza.type import TextBlock, ROLE memory = Memory() memory.add_turn(TextBlock(content=prompt), role=ROLE.SYSTEM) while True : ## User q = input('🙂 >') if q == "quit": break ## LLM llm_res = ollama.invoke(q, memory=memory) res = llm_res.text print("🍕 >", f"\x1b[1;30m{res}\x1b[0m")

    ## Update Memory
    memory.add_turn(TextBlock(content=q), role=ROLE.USER)
    memory.add_turn(TextBlock(content=res), role=ROLE.ASSISTANT)

If you want to retrieve the chat history, you can just access the memory. Usually, AI frameworks use three roles in the interaction with an LLM: “system” (core instructions), “user” (what was said by the human), “assistant” (what the chatbot replied).

memory.to_dict()

Obviously, the LLM alone is very limited and it can’t do much besides chatting. Therefore, we need to give it the possibility to take action, or in other words, to activate Tools.

Tools

Tools are the main difference between a simple LLM and an AI Agent. When the user requests something that goes beyond the LLM knowledge base (i.e. “what time is it now?“), the Agent should understand that it doesn’t know the answer, activate a Tool to get additional information (i.e. checking the clock), elaborate the result through the LLM, and generate an answer.

The Datapizza framework allows you to create Tools from scratch very easily. You just need to import the decorator @tool and any function can become actionable for the Agent.

from datapizza.tools import tool

@tool
def get_time() -> str:
    '''Get the current time.'''
    from datetime import datetime
    return datetime.now().strftime("%H:%M")

get_time()

Then, assign the designated Tool to the Agent, and you’ll have an AI that combines language understanding + autonomy decision making + tool use.

from datapizza.agents import Agent
import os

os.environ["DATAPIZZA_AGENT_LOG_LEVEL"] = "DEBUG" #max agent de journalisation = Agent(name="single-agent", client=ollama, system_prompt=prompt, tools=[get_time]max_steps=2) q = ''' quelle heure est-il ? ''' agent_res = agent.run(q)

Un agent IA basé sur LLM est un système intelligent construit autour d’un modèle de langage qui non seulement répond, mais qui raisonne, décide et agit. Outre la conversation (ce qui signifie discuter avec une base de connaissances à usage général), les actions les plus courantes que les agents peuvent effectuer sont CHIFFON (discuter avec vos documents), Interrogation (discuter avec une base de données), Recherche sur le Web (discuter avec tout Internet).

Par exemple, essayons un outil de recherche sur le Web. En Python, le plus simple est d’utiliser le fameux navigateur privé CanardCanardAller. Vous pouvez directement utiliser le bibliothèque originale ou le wrapper du framework Datapizza (pip install datapizza-ai-tools-duckduckgo).

from datapizza.tools.duckduckgo import DuckDuckGoSearchTool

DuckDuckGoSearchTool().search(query="powell")

Créons un agent capable de rechercher sur le Web pour nous. Si vous souhaitez le rendre plus interactif, vous pouvez structurer l’IA comme je l’ai fait pour le Chatbot.

os.environ["DATAPIZZA_AGENT_LOG_LEVEL"] = "ERREUR" #désactiver l'invite de journalisation = ''' Vous êtes journaliste. Vous devez faire des hypothèses, utiliser votre outil pour rechercher, deviner et formuler une réponse finale. La réponse finale doit contenir des faits, des dates et des preuves pour étayer votre supposition. ''' mémoire = Mémoire() agent = Agent(name="single-agent", client=ollama, system_prompt=prompt, tools=[DuckDuckGoSearchTool()]mémoire=mémoire, max_steps=2) while True : ## Utilisateur q = input('🙂 >') if q == "quit": break ## Agent agent_res = agent.run(q) res = agent_res.text print("🍕 >", f"\x1b[1;30m{res}\x1b[0m")

    ## Update Memory
    memory.add_turn(TextBlock(content=q), role=ROLE.USER)
    memory.add_turn(TextBlock(content=res), role=ROLE.ASSISTANT)

Multi-Agent System

The real strength of Agents is the ability to collaborate with each other, just like humans do. These teams are called Multi-Agent Systems (MAS), a group of AI Agents that work together in a shared environment to solve complex problems that are too difficult for a single one to handle alone.

This time, let’s create a more advanced Tool: code execution. Please note that LLMs know how to code by being exposed to a large corpus of both code and natural language text, where they learn patterns, syntax, and semantics of programming languages. But since they can not complete any real action, the code they create is just text. In short, LLMs can generate Python code but can’t execute it, Agents can.

import io
import contextlib

@tool
def code_exec(code:str) -> str:
    '''Execute python code. Use always the function print() to get the output'''
    output = io.StringIO()
    with contextlib.redirect_stdout(output):
        try:
            exec(code)
        except Exception as e:
            print(f"Error: {e}")
    return output.getvalue()

code_exec("from datetime import datetime; print(datetime.now().strftime('%H:%M'))")

There are two types of MAS: the sequential process ensures tasks are executed one after the other, following a linear progression. On the other hand, the hierarchical structure simulates traditional organizational hierarchies for efficient task delegation and execution. Personally, I tend to prefer the latter as there is more parallelism and flexibility.

With the Datapizza framework, you can link two or more Agents with the function can_call(). In this way, one Agent can pass the current task to another Agent.

prompt_senior = '''
You are a senior Python coder. You check the code generated by the Junior, 
and use your tool to execute the code only if it's correct and safe.
'''
agent_senior = Agent(name="agent-senior", client=ollama, system_prompt=prompt_senior, 
                     tools=[code_exec]) prompt_junior = ''' Vous êtes un codeur Python junior. Vous pouvez générer du code mais vous ne pouvez pas l'exécuter. Vous recevez une demande du gestionnaire et votre sortie finale doit être du code Python à transmettre. Si vous ne connaissez pas certaines commandes spécifiques, vous pouvez utiliser votre outil et rechercher sur le Web « comment… avec python ? ''' agent_junior = Agent(name="agent-junior", client=ollama, system_prompt=prompt_junior, tools=[DuckDuckGoSearchTool()]) agent_junior.can_call([agent_senior]) prompt_manager = ''' Vous n'y connaissez rien, vous n'êtes qu'un manager. Après avoir reçu une demande de l'utilisateur, vous demandez d'abord au Junior de générer le code, puis vous demandez au Senior de l'exécuter. ''' agent_manager = Agent(name="agent-manager", client=ollama, system_prompt=prompt_manager, tools=[]) agent_manager.can_call([agent_junior, agent_senior]) q = ''' Tracez la trame de données Titanic. Vous pouvez trouver les données ici : https://raw.githubusercontent.com/mdipietro09/DataScience_ArtificialIntelligence_Utils/master/machine_learning/data_titanic.csv ''' agent_res = agent_manager.run(q) #print(agent_res.text)

Conclusion

Cet article a été un tutoriel pour introduire IA Datapizzaun tout nouveau framework pour créer des chatbots et des agents IA basés sur LLM. La bibliothèque est très flexible et conviviale, et peut couvrir différents cas d’utilisation de GenAI. Je l’ai utilisé avec Ollama, mais il peut être lié à tous les moteurs connus, comme OpenAI.

Code complet pour cet article : GitHub

J’espère que vous l’avez apprécié ! N’hésitez pas à me contacter pour des questions et des commentaires ou simplement pour partager vos projets intéressants.

👉 Connectons-nous 👈

_{^{(Toutes les images sont de l’auteur, sauf indication contraire)}}