Les agents de développement logiciel basés sur l’IA sont en train de transformer la façon dont les équipes travaillent.
Au lieu de s’appuyer uniquement sur des outils fermés comme CLI Code Claude, Gemini CLI ou Codex, il est aujourd’hui possible de créer son propre agent de développement CLI personnalisé avec quelques dizaines de lignes de Python.
Dans ce tutoriel, nous allons décortiquer un exemple d’agent qui combine :
- Pydantic-AI pour orchestrer l’agent,
- OpenAI comme modèle de langage,
- et plusieurs MCP servers (Model Context Protocol) pour connecter des outils externes.
1. Initialiser le modèle OpenAI
Nous allons utiliser pydantic_ai.models.openai.OpenAIChatModel.
L’agent lira directement la clé API OPENAI_API_KEY définie dans vos variables d’environnement.
from pydantic_ai.models.openai import OpenAIChatModel
from pydantic_ai.providers.openai import OpenAIProvider
openai_provider = OpenAIProvider() # lit OPENAI_API_KEY dans l'environnement
model = OpenAIChatModel(
model_name="gpt-4o", # modèle choisi
provider=openai_provider
)
👉 Ici, nous utilisons gpt-4o, mais il est possible de basculer sur gpt-4o-mini (plus économique) ou o3-mini (spécialisé dans le raisonnement).
2. Définir les instructions de l’agent
Un agent n’est pas seulement un LLM. Il doit être guidé par des règles précises qui orientent son comportement.
instructions = """ You are a specialised agent for maintaining and developing the XXXXXX codebase. ## Development Guidelines: 1. **Test Failures:** - When tests fail, fix the implementation first, not the tests - Tests represent expected behavior; implementation should conform to tests - Only modify tests if they clearly don't match specifications 2. **Code Changes:** - Make the smallest possible changes to fix issues - Focus on fixing the specific problem rather than rewriting large portions - Add unit tests for all new functionality before implementing it 3. **Best Practices:** - Keep functions small with a single responsibility - Implement proper error handling with appropriate exceptions - Be mindful of configuration dependencies in tests Remember to examine test failure messages carefully to understand the root cause before making any changes. """
Ces instructions définissent un cadre méthodologique pour que l’agent respecte les bonnes pratiques de développement.
3. Ajouter des serveurs MCP (Model Context Protocol)
Le protocole MCP permet de connecter l’agent à des outils externes.
Chaque serveur MCP est lancé via MCPServerStdio, qui démarre un processus externe avec lequel l’agent peut dialoguer.
Exemple : exécuter du code Python en sandbox avec Deno :
from pydantic_ai.mcp import MCPServerStdio
run_python = MCPServerStdio(
"deno",
args=[
"run",
"--allow-net",
"--allow-read=.",
"--allow-write=.",
"--allow-run",
"--allow-env",
"--node-modules-dir=auto",
"jsr:@pydantic/mcp-run-python",
"stdio",
],
)
Autres serveurs utilisés dans ce projet :
internet_search = MCPServerStdio(command="uvx", args=["duckduckgo-mcp-server"])
code_reasoning = MCPServerStdio(
command="npx",
args=["-y", "@mettamatt/code-reasoning"],
tool_prefix="code_reasoning",
)
desktop_commander = MCPServerStdio(
command="npx",
args=["-y", "@wonderwhy-er/desktop-commander"],
tool_prefix="desktop_commander",
)
awslabs = MCPServerStdio(
command="uvx",
args=["awslabs.core-mcp-server@latest"],
env={
"FASTMCP_LOG_LEVEL": "DEBUG",
"AWS_EC2_METADATA_DISABLED": "true",
},
tool_prefix="awslabs",
)
aws_docs = MCPServerStdio(
command="uvx",
args=["awslabs.aws-documentation-mcp-server@latest"],
env={
"FASTMCP_LOG_LEVEL": "DEBUG",
"AWS_DOCUMENTATION_PARTITION": "aws",
"AWS_EC2_METADATA_DISABLED": "true",
},
tool_prefix="aws_docs",
)
context7 = MCPServerStdio(
command="npx", args=["-y", "@upstash/context7-mcp"], tool_prefix="context"
)
👉 Chacun de ces serveurs MCP ajoute des capacités spécialisées à l’agent : recherche, exécution de code, documentation AWS, automatisation du bureau…
4. Construire l’agent
On assemble maintenant tous les éléments (modèle, instructions, serveurs MCP) dans un objet Agent :
from pydantic_ai import Agent
agent = Agent(
instructions=instructions,
model=model,
mcp_servers=[
run_python,
internet_search,
code_reasoning,
context7,
awslabs,
aws_docs,
desktop_commander,
],
)
5. Ajouter un outil Python personnalisé
En plus des serveurs MCP, nous pouvons ajouter nos propres outils Python.
Exemple : lancer des tests unitaires avec pytest.
import subprocess
@agent.tool_plain()
def run_unit_tests() -> str:
"""Run unit tests using uv."""
result = subprocess.run(
["uv", "run", "pytest", "-xvs", "tests/"],
capture_output=True, text=True
)
return result.stdout
Cet outil devient alors disponible pour l’agent comme s’il s’agissait d’un outil externe.
6. Lancer l’agent en CLI
Enfin, nous lançons l’agent dans le terminal :
import asyncio
async def main():
async with agent.run_mcp_servers():
await agent.to_cli()
if __name__ == "__main__":
asyncio.run(main())
À l’exécution, vous obtenez une boucle interactive dans laquelle vous pouvez dialoguer avec l’agent. Celui-ci peut alors :
- analyser du code,
- exécuter des tests,
- chercher de la documentation,
- interagir avec l’environnement local.
Pourquoi c’est important pour les PME ?
Cet exemple montre le potentiel énorme des agents IA personnalisés :
- Souveraineté : possibilité d’utiliser un LLM open source au lieu d’OpenAI.
- Adaptabilité : choix des MCP servers en fonction des besoins métier.
- Productivité : automatisation de tâches de développement, de documentation et de test.
Contrairement aux solutions “clé en main”, vous gardez la main sur l’architecture et les données.
Conclusion : prochaine étape, spécialiser l’agent pour Odoo
Nous avons vu comment construire un agent de développement CLI avec Pydantic-AI, OpenAI et plusieurs MCP servers.
Cet agent est déjà capable d’écrire du code, d’exécuter des tests et d’utiliser des outils externes.
👉 La prochaine étape ?
Spécialiser cet agent pour le développement de modules Odoo :
- génération de modèles et vues QWeb,
- validation de règles métiers,
- automatisation de scénarios de tests,
- assistance à la migration entre versions.
Ci-dessous une petite démonstration ce ce que notre agent peut faire.
Un tel agent représenterait un levier stratégique pour les intégrateurs Odoo et les PME qui souhaitent accélérer leur développement tout en gardant la qualité et la maîtrise de leurs projets.