AWS Builder Center

Builder Center

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

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

Découvrez le framework Strands et voyons comment il va vous aider à accélérer le développement et le déploiement de vos agents IA.

Olivier Leplus

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 :
Strands components

  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.
  1. Les outils (tools) : Des fonctions Pyhon ou des serveurs MCP (Model Context Protocol)
  1. 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) :
shell
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:
shell
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:
Python
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

Boucle agentique

Strands utilise une boucle agentique qui
  1. Analyse le prompt et le contexte,
  1. Demande au LLM de planifier les étapes pour répondre au prompt,
  1. Sélectionne les outils (tools) appropriés,
  1. Exécute les outils (tools) choisis,
  1. 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.
Python
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:
Python
# 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,
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  :
Python
@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 :
Python
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é.
# generative-ai# technology-frameworks# python
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article