Le Blog Amazon Web Services

Strands : Le framework Python qui facilite la création d’agents IA

Strands est un SDK Python pour créer des agents IA. Plutôt que de définir des workflows complexes, il suffit simplement de donner un modèle, des outils (tools) et un prompt à notre agent. Le modèle (LLM) se charge ensuite de la planification, du raisonnement et de l’exécution des outils. Dans ce blog post, vous allez découvrir le framework Strands et voir comment il va vous aider à accélérer le développement et le déploiement de vos agents IA.

Plongeons ensemble au cœur de cette innovation qui réussit à allier performance technique et expérience utilisateur exceptionnelle.

Architecture Fondamentale

Un agent Strands se compose de trois composants essentiels :

  1. Le modèle : Strands peut travailler avec plusieurs modèles et supporte des providers comme Amazon Bedrock, Anthropic Claude, Llama, Ollama, OpenAI où même notre propre provider custom.
  2. Les outils (tools) : Des fonctions Pyhon ou des serveurs MCP (Model Context Protocol)
  3. Le prompt : Les instructions en langage naturel qui décrivent les tâches que nous voulons que notre agent exécutent.

Installation

Pour installer Strands et créer notre premier agent, créons un environnement virtuel Python (Python 3.10+ est requis) :

python -m venv .venv
source .venv/bin/activate  # Linux/macOS
# ou .venv\Scripts\activate.bat sur Windows

Installez le SDK Strands ainsi qu’une collection d’outils:

pip install strands-agents strands-agents-tools strands-agents-builder

Notre premier agent

Maintenant que nous avons notre environnement et tous les outils installés, nous pouvons commencer à coder ^^.

Dans l’exemple ci-dessous, nous tirons parti des outils intégrés dans le package strands-agents-tools et créons notre propre outil qui lance un dé. Nous ajoutons ensuite tous ces outils à notre agent et lui donnons des tâches à accomplir:

from strands import Agent, tool
import random
from strands_tools import calculator, current_time, python_repl

# Définir un outil personnalisé avec le décorateur @tool
@tool
def roll_dice(sides: int):
    """Roll a dice with the specified number of sides.
    
    Args:
        sides: The number of sides on the dice.
        
    Returns:
        A random integer between 1 and the number of sides.
    """

    return random.randint(1, sides)

# Créer un agent avec des outils intégrés et personnalisés
agent = Agent(
    tools=[calculator, current_time, python_repl, roll_dice]
    )

# Poser une question qui utilise les outils disponibles
message = """
I have 4 requests:

1. What is the time right now?
2. Calculate 3111696 / 74088
3. Roll a dice of 20
4. Output a script that does what we just spoke about!
   Use your python tools to confirm that the script works before outputting it
"""

agent(message)

Dans cet exemple, nous utilisons des tools existants comme calculator, current_time et python_repl mais créons aussi notre propre tool en ajoutant le décoratuer @agent à la fonction roll_dice.

Boucle Agentique

Strands utilise une boucle agentique qui

  1. Analyse le prompt et le contexte,
  2. Demande au LLM de planifier les étapes pour répondre au prompt,
  3. Sélectionne les outils (tools) appropriés,
  4. Exécute les outils (tools) choisis,
  5. Répète jusqu’à accomplissement de la tâche.

Cette approche tire parti des capacités natives des LLM modernes pour le raisonnement et l’utilisation d’outils.

Configuration des modèles

Modèle par défaut (Amazon Bedrock)

Par défaut, Strands utilise Amazon Bedrock avec Claude 3.7 Sonnet.
Nous pouvons personaliser les paramètres du modèle en créant une instance du modèle provider.

from strands import Agent
from strands.models import BedrockModel

# Configuration avec Bedrock
bedrock_model = BedrockModel(
    model_id="us.anthropic.claude-3-7-sonnet-20250219-v1:0",
    region_name='us-west-2',
    temperature=0.3,
)

agent = Agent(model=bedrock_model)

Autres Fournisseurs

Mais comme nous l’avons mentionné plus haut, Strands est indépendant du modèle utilisé. On peut donc définir un autre modèle que celui par défaut pour éxécuter notre agent:

# Anthropic Claude
# pip install 'strands-agents[anthropic]'
from strands.models import AnthropicModel

anthropic_model = AnthropicModel(
    client_args={
        "api_key": "<KEY>",
    },
    max_tokens=1028,
    model_id="claude-3-7-sonnet-20250219",
    params={
        "temperature": 0.7,
    }
)

# Ollama (développement local)
# pip install 'strands-agents[ollama]'
from strands.models import OllamaModel
ollama_model =  OllamaModel(
    host="http://localhost:11434",
    model_id="llama3"
)

Les outils (tools)

Les outils (tools) permettent à notre agent d’interagir avec le monde extérieur et d’exécuter des actions concrètes. Strand propose trois types d’outils :

  • les outils intégrés comme calculator et current_time pour les fonctionnalités de base,
  • les outils personnalisés que nous avons codé nous-même,
  • les outils MCP qui donnent accès à des milliers d’outils externes via le protocole Model Context Protocol (MCP).

Outils intégrés

Par défaut, Strands fournit de nombreux outils comme par exemple :

  • calculator : Opérations mathématiques
  • current_time : Informations sur la date et l’heure
  • python_repl : Exécution de code Python
  • file_read & file_write : Lecture/écriture
  • http_request : Appels HTTP
  • …

Vous pouvez retrouver la liste de tous les outils dans la documentation de Strands.

Fonctions python

La force de Strands réside dans sa simplicité. Il permet de transformer n’importe quelle fonction Python en outil avec @tool :

@tool
def roll_dice(sides: int):
    """Roll a dice with the specified number of sides.
    
    Args:
        sides: The number of sides on the dice.
        
    Returns:
        A random integer between 1 and the number of sides.
    """

    return random.randint(1, sides)

La convention docstring permet de définir la description, les arguments et ce que retourne notre outil. C’est grâce à celà que notre agent pourra identidier le bon outil à appeler.

Model Context Protocol (MCP)

Nous pouvons accéder à des milliers d’outils via le protocole MCP pour étendre les capacités de vos agents. Retrouvez plus d’informations sur comment connecter Strands à un serveur MCP dans la section MCP de la documentation Strands.

Débogage et Logs

Nous pouvons activer les logs de debug pour analyser le comportement et débugger notre agent :

import logging
from strands import Agent

# Active les logs de débogage Strands
logging.getLogger("strands").setLevel(logging.DEBUG)

logging.basicConfig(
    format="%(levelname)s | %(name)s | %(message)s",
    handlers=[logging.StreamHandler()]
)

agent = Agent()
agent("Hello!")

Cas d’usage techniques

En tirant parti des outils intégrés, de la possibilité de se connecter à des serveurs MCP et à coder notre propre outil, Strands peut nous aider dans plusieurs domaines :

  • Développement logiciel : Génération et révision de code
  • Analyse de données : Traitement et visualisation
  • Automatisation : Tâches répétitives et workflows
  • Support technique : Agents conversationnels spécialisés
  • Recherche et analyse : Synthèse d’informations complexes

Déploiement

Strands nous permet de développer en local mais aussi de tourner en production. Le framework supporte la mise à l’échelle, la gestion d’état distribuée, le monitoring et la sécurité.

Nous pouvons aussi bien déployer notre agent sur une fonction Lambda, sur AWS Fargate, Amazon EKS ou Amazon EC2. Retrouvez plus d’infos sur chaque type de déploiement dans la section « Operating agents in production » de la documentation de Strands.

Conclusion

Strands simplifie la création d’agents IA en Python grâce à son approche pilotée par le modèle. Il est possible de créer des agents sophistiqués en quelques lignes de code et les déployer rapidement. Grâce à son support de multiples modèles, son API haut niveau pour créer et intégrer des outils dans votre agent, Strands offre une solution simple, que ce soit pour le prototypage ou la mise en production.

Codez votre premier agent aujourd’hui en suivant le Getting Started !

Ressources : GitHub Strands Agents | Documentation

Strands Agents est open source et accueille les contributions de la communauté.

Benoît Mariaux

Olivier Leplus

Olivier Leplus est Développeur Advocate au sein de l’organisation Developer Experience d’AWS. Il travaille en étroite collaboration avec les services teams et les utilisateurs d’AWS afin de s’assurer que l’expérience développeur soit fluide, efficace et adaptée à leurs besoins, en partageant les bonnes pratiques, en créant des contenus techniques, et en relayant les retours terrain.