[talk] Créer un maître du jeu (de rôle) multi-agents avec Strands!.md

SLIDES

Question: Avant de parler de Strands, on va parler terminologie. Qui c'est ce qu'est MCP?

• Model Context Protocol. Un protocol ouvert qui standardise la façon dont les agents peuvent se connecter à des services externes comme des bases de données, des APIs, des systèmes légacy plutôt que d'avoir à gérer une intégration custom pour chaque service.
• Du coup on a une interface standard pour gérer ses connections. C'est un peu come REST mais pour les agents IA.
• Et on verra que Strands supporte nativement les connections à des serveurs MCP pour utiliser leurs tools

Question: Deuxième concept. Qui c'est ce qu'est un agent?

• Au commencement nous avions les LLMs. Les LLMs qui pouvaient gérer des conersations mais qui ne pouvaient pas sortir de leur base de connaissance, qui ne pouvaient pas faire d'autres choses que de restituer ce qu'ils avaient apris
• En fait un agent, c'est un LLM qui peut agir. Il reçoit un input d'un utilisateur, il va raisonner au meilleur moyen de vous répondre et il va exécuter des tâches en utilisant les outils qu'il a a sa disposition. Et ensuite il vous répond.
  Il y a 3 choses qui font qu'un agent IA c'est cool:
  • Il raisonne. Il ne fait pas que répondre, il décide des différentes étapes à faire avant
  • Il utilise des tools. Il peut appeler des APIs, des bases de données ou d'autre s services. Il ne fait pas que générer du texte à partir de ce qu'il a appris
  • Il a un context. Il peut gérer une mémoire ou des règles pour rester consistent entre les étapes Dans Strands, on verra que les agents sont composables. Il peut les connecter comme des blocs de Lego ou on donne à chaque agent un rôle, des tools et on les laissent collaborer.

C'est magique!

Tout ça c'est bien beau mais ça devient un peu compliqué à coder. C'est là qu'intervient Strands. Strands Agents, de son vrai nom, c'est un SDK open source pour développer des agents IA en quelques lignes de code avec le support des protocoles MCP et A2A pour la communication entre agents.
Aujourd'hui Strands est disponible en Python.

Une architecture typique, comme on pourrait la développer pour un JDR, ressemblerait à un workflow multi-agentique grâce au protocole A2A. On aurait un agent orchestrateur qui serait connecté à 3 agents. L'orchestrateur est aussi un agent d'ailleurs mais il a le rôle de décider à quels agents il va faire appel en fonction de ce qu'on lui donne. C'est à lui que vous avez accès. Et ensuite chaque agent à accès à des tools en fonction de sa fonction (ex: gestion des rêgles: RAG, etc, gestion des personnages: BDD, etc)

DEMO

1. Création d'un agent

Snippet: Import Strands

from strands import Agent

agent = Agent()

agent("Coucou, comment ça va à Bordeaux?")

Execute

Explications

• On a un agent qui tourne en 3 lignes de code
• Par défaut il utilise Claude sonnet 4

print(agent.model.config)

Execute

Mais on a dit tout à l'heure que Strands était model provider agnostic, on peut utiliser autre chose. Même en local

Snippet: Import OllamaModel

from strands.models.ollama import OllamaModel

Aller chercher les infos de ollama dans la console

> ollama serve # url
> ollama list # choisir un modèle

model_ollama = OllamaModel(
    host="localhost:11434",
    model_id="llama3.2:latest"
)

agent = Agent(
    model=model_ollama
)

Exectuter

Aller voir la page https://strandsagents.com/latest/documentation/docs/ et montrer tous les modèles providers

Si on a le temps, faire un exemple avec Bedrock?

Enlever le code Ollama

Build-in tools

Le problème des LLMs c'est qu'ils sont limités et en général si on crée des agents c'est justement pour étendre leurs capacités. Un exemple courant c'est de demander l'heure à un LLM

agent("Quelle heure est-il?")

Executer

from strands_tools import current_time

...

agent = Agent(
    tools=[current_time]
)

Executer

Montrer que le tool est bien apelé

Montrer la page des community tools https://strandsagents.com/latest/documentation/docs/user-guide/concepts/tools/community-tools-package/

Faire un autre exemple plus avancé

from strands_tools import current_time, file_write, python_repl

agent = Agent(
    tools=[current_time, file_write, python_repl]
)

agent("Ecris un fichier fib.py qui calcul les x premieres itérations de la suite de fibbonacci et exécute le")

Executer

Montrer aussi le fichier fib.py créé

Python tools

On a donc toute une liste d'outils dans le package strands-agents-tools mais il peut arriver qu'on ai besoin d'autres outils. Vous voulez aller chercher des infos dans une base de donnée par exemple, ou autre

Si on repart sur notre idée de jeu de rôle, je voudrai un outil qui peut lancer des dés

Snippet: roll dice method (only the body of the function)

Ask Kiro: Cmd+I: Write the function that rolls a dice with a number of faces passed as a string. Mange errors

def roll_dice(faces):

Demander à Kiro d'écrire le body de la fonction (fallback sur le snippet si il n'y arrive pas)

from strands import tool

@tool
def roll_dice(faces):
    ...

agent = Agent(
    tools=[roll_dice]
)

agent("Tu es un maitre du jeu Donjon et Dragon. Lance 3d20")

MCP server

Bon ça marche mais on ne va pas coder tous nos outils ici. Et puis quand bien même on découperait notre code, aujourd'hui on utilise de plus en plus des serveurs MCP. Imaginons qu'on veuille soit donner accès à notre outil de lancé de dés à d'autres personnes, soit utiliser un serveur MCP qui le fait déjà.

Copier/coller la methode roll_dice dans un nouveau fichier mcp_server.py

Ici, on va utiliser FastMCP qui est un framework qui permet de créer des serveurs et des clients MCPs rapidement

Snippet: Import FastMCP

from mcp.server import FastMCP

Let's create our server

mcp = FastMCP(
    name="D&D Dice Roll Service",
    host="0.0.0.0",
    port=8080
)

...


if __name__ == "__main__":
    mcp.run(transport="streamable-http")

Et on a juste comme tout à l'heure a rajouter un décorateur à notre fonction

@mcp.tool()
def roll_dice(faces):
    ...

Run the mcp server in a terminal window

Dans app.py

First let's create an MCPClient.

from strands.tools.mcp.mcp_client import MCPClient
from mcp.client.streamable_http import streamablehttp_client

mcp_dice_client = MCPClient(lambda: streamablehttp_client("http://localhost:8080/mcp"))

Explain that there are different ways of using MCP, here we are using a url. Quickly show the different ways in the documentation https://strandsagents.com/latest/documentation/docs/user-guide/concepts/tools/mcp-tools/

try:
    with mcp_dice_client:
        mcp_tools = mcp_dice_client.list_tools_sync()
        
        print(f"Connected to MCP Dice Server. Available tools: {[tool.tool_name for tool in mcp_tools]}")
        
        agent = Agent(
            tools=mcp_tools
        )
        agent("Roll a 3 d6")
except Exception as e:
    print(f"Warning: Could not connect to MCP Dice Server: {e}")

Execute

Agent 2 Agent

On a vu comment créer des outils directement dans notre agent. On a vu comment connecter notre agent à un serveur MCP, et au passage petit bonus comment créer un serveur MCP avec ses outils.

Maintenant, si on veut créer différents agents et les faire travailler ensemble. Par exemple si je veux un agent qui va gérer mes personnages?

Créer un fichier character_agent.py

C'est assez simple on fait un peu la même chose qu'au début

Snippet: character agent description => Juste pour la description

agent = Agent(
    name="DnD character management agent",
    description="""
        Crée et gère les personnages de DnD avec leur nom, classe, race, statistiques et leur backgroun
        Tu peux écrire et lire les fichiers de personnage
        """,
    tools=[file_write, file_read]
)

Et là au lieu d'appeler l'agent nous-même, vu que c'est notre agent game master qui va l'appeler, on va créer un serveur

from strands.multiagent.a2a import A2AServer

...

a2a_server = A2aServer(
    agent=agent,
    port=8081
)

a2a_server.serve(hpst="0.0.0.0", post=8081)

Snippet: Import A2AClientProvider

from strands_tools.a2a_client import A2AClientToolProvider

a2aprovider = A2AClientToolProvider(known_agent_urls=[
    "http://localhost:8081",
])


...
tools=mcp_tools + a2aprovider.tools
...

Une bonne pratique quand on commence a avoir plusieurs serveurs MCP ou agents auquels on se connecte, c'est d'écrire un système prompt pour décrire à notre agent principal ce qu'il peut faire et comment

system_prompt="""
    Tu est un game master de DnD
        Tu as accès a différents tools et agents. Utilise les quand tu veux:
        - lancer des dés
        - Créer ou récupérer des informations ou gérer des personnages
    """

agent("""
        Crée un personnage nommé Olivier qui est un elf de la nuit. Lance les dés pour générer ses statistiques.
        Ensuite, écrit le personnage dans un fichier
        """)

agent("Que peux-tu me dire sur le personnage Olivier")