{

"title": {

"message": "Blog",

"description": "The title for the blog used in SEO"

},

"description": {

"message": "Blog",

"description": "The description for the blog used in SEO"

},

"sidebar.title": {

"message": "Articles récents",

"description": "The label for the left sidebar"

}

}

{

"version.label": {

"message": "Next",

"description": "The label for version current"

},

"sidebar.docsSidebar.category.🤖 Backends LLM": {

"message": "🤖 Backends LLM",

"description": "The label for category 🤖 Backends LLM in sidebar docsSidebar"

},

"sidebar.docsSidebar.category.🚧 Dépannage": {

"message": "🚧 Dépannage",

"description": "The label for category 🚧 Dépannage in sidebar docsSidebar"

},

"sidebar.apiSidebar.category.Backend": {

"message": "Backend",

"description": "The label for category Backend in sidebar apiSidebar"

}

}

Les documents apparaîtront ici après le déploiement.

{

"items": ["python/python"],

"label": "Backend",

"type": "categorie"

}

sidebar_position: 7

La réalisation d'une réplication complète des applications de production avec les LLM est une entreprise complexe. Notre stratégie implique :

1. **Recherche Technique de Base :** Se concentrer sur la recherche fondamentale pour comprendre et améliorer les aspects techniques de la génération et de la gestion de code.

2. **Compétences Spécialisées :** Améliorer l'efficacité des composants de base grâce à la curation des données, aux méthodes de formation, et plus encore.

3. **Planification des Tâches :** Développer des capacités pour la détection de bogues, la gestion du code source et l'optimisation.

4. **Évaluation :** Établir des métriques d'évaluation complètes pour mieux comprendre et améliorer nos modèles.

- Notre agent par défaut est actuellement le CodeActAgent, capable de générer du code et de gérer des fichiers. Nous travaillons sur d'autres implémentations d'agents, y compris [SWE Agent](https://swe-agent.com/). Vous pouvez [lire à propos de notre ensemble actuel d'agents ici](./agents).

OpenDevin est un projet communautaire, et nous accueillons les contributions de tout le monde. Que vous soyez développeur, chercheur, ou simplement enthousiaste à l'idée de faire progresser le domaine de l'ingénierie logicielle avec l'IA, il existe de nombreuses façons de vous impliquer :

- **Contributions de Code :** Aidez-nous à développer les fonctionnalités de base, l'interface frontend ou les solutions de sandboxing.

- **Recherche et Évaluation :** Contribuez à notre compréhension des LLM en ingénierie logicielle, participez à l'évaluation des modèles ou suggérez des améliorations.

- **Retour d'Information et Tests :** Utilisez l'ensemble d'outils OpenDevin, signalez des bogues, suggérez des fonctionnalités ou fournissez des retours sur l'ergonomie.

Pour plus de détails, veuillez consulter [ce document](https://github.com/OpenDevin/OpenDevin/blob/main/CONTRIBUTING.md).

Nous avons maintenant à la fois un espace de travail Slack pour la collaboration sur la construction d'OpenDevin et un serveur Discord pour discuter de tout ce qui est lié, par exemple, à ce projet, aux LLM, aux agents, etc.

- [Espace de travail Slack](https://join.slack.com/t/opendevin/shared_invite/zt-2jsrl32uf-fTeeFjNyNYxqSZt5NPY3fA)

- [Serveur Discord](https://discord.gg/ESHStjSjD4)

Si vous souhaitez contribuer, n'hésitez pas à rejoindre notre communauté. Simplifions l'ingénierie logicielle ensemble !

🐚 **Codez moins, créez plus avec OpenDevin.**

[](https://star-history.com/#OpenDevin/OpenDevin&Date)

OpenDevin est construit en utilisant une combinaison de cadres et de bibliothèques puissants, offrant une base robuste pour son développement. Voici les technologies clés utilisées dans le projet :

       

Veuillez noter que la sélection de ces technologies est en cours, et que des technologies supplémentaires peuvent être ajoutées ou des existantes supprimées au fur et à mesure de l'évolution du projet. Nous nous efforçons d'adopter les outils les plus adaptés et efficaces pour améliorer les capacités d'OpenDevin.

Distribué sous la licence MIT. Voir [notre licence](https://github.com/OpenDevin/OpenDevin/blob/main/LICENSE) pour plus d'informations.

sidebar_position: 3

Cet agent implémente l'idée CodeAct ([article](https://arxiv.org/abs/2402.01030), [tweet](https://twitter.com/xingyaow_/status/1754556835703751087)) qui consolide les **act**ions des agents LLM en un espace d'action **code** unifié pour à la fois la _simplicité_ et la _performance_ (voir article pour plus de détails).

L'idée conceptuelle est illustrée ci-dessous. À chaque tour, l'agent peut :

1. **Converse** : Communiquer avec les humains en langage naturel pour demander des clarifications, des confirmations, etc.

2. **CodeAct** : Choisir d'accomplir la tâche en exécutant du code

- Exécuter toute commande `bash` Linux valide

- Exécuter tout code `Python` valide avec [un interpréteur Python interactif](https://ipython.org/). Cela est simulé à travers la commande `bash`, voir le système de plugin ci-dessous pour plus de détails.


Pour rendre l'agent CodeAct plus puissant avec seulement l'accès à l'espace d'action `bash`, l'agent CodeAct exploite le système de plugins d'OpenDevin:

- [Plugin Jupyter](https://github.com/OpenDevin/OpenDevin/tree/main/opendevin/runtime/plugins/jupyter) : pour l'exécution d'IPython via la commande bash

- [Plugin outil agent SWE](https://github.com/OpenDevin/OpenDevin/tree/main/opendevin/runtime/plugins/swe_agent_commands) : Outils de ligne de commande bash puissants pour les tâches de développement logiciel introduits par [swe-agent](https://github.com/princeton-nlp/swe-agent).

_Exemple de CodeActAgent avec `gpt-4-turbo-2024-04-09` effectuant une tâche de science des données (régression linéaire)_

`Action`,

`CmdRunAction`,

`IPythonRunCellAction`,

`AgentEchoAction`,

`AgentFinishAction`,

`CmdOutputObservation`,

`IPythonRunCellObservation`,

`AgentMessageObservation`,

| Méthode | Description |

| ---------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |

| `__init__` | Initialise un agent avec `llm` et une liste de messages `list[Mapping[str, str]]` |

| `step` | Effectue une étape en utilisant l'agent CodeAct. Cela inclut la collecte d'informations sur les étapes précédentes et invite le modèle à exécuter une commande. |

| `search_memory` | Pas encore implémenté |

[] Support de la navigation sur le web

[] Compléter le workflow pour l'agent CodeAct afin de soumettre des PRs Github

L'agent Monologue utilise la mémoire à long terme et à court terme pour accomplir des tâches.

La mémoire à long terme est stockée en tant qu'objet LongTermMemory et le modèle l'utilise pour rechercher des exemples du passé.

La mémoire à court terme est stockée en tant qu'objet Monologue et le modèle peut la condenser si nécessaire.

`Action`,

`NullAction`,

`CmdRunAction`,

`FileWriteAction`,

`FileReadAction`,

`AgentRecallAction`,

`BrowseURLAction`,

`GithubPushAction`,

`Observation`,

`NullObservation`,

`CmdOutputObservation`,

`FileReadObservation`,

`AgentRecallObservation`,

| Méthode | Description |

| --------------- | --------------------------------------------------------------------------------------------------------------------------------------------- |

| `__init__` | Initialise l'agent avec une mémoire à long terme et un monologue interne |

| `_add_event` | Ajoute des événements au monologue de l'agent et condense avec un résumé automatiquement si le monologue est trop long |

| `_initialize` | Utilise la liste `INITIAL_THOUGHTS` pour donner à l'agent un contexte pour ses capacités et comment naviguer dans le `/workspace` |

| `step` | Modifie l'état actuel en ajoutant les actions et observations les plus récentes, puis invite le modèle à réfléchir à la prochaine action à entreprendre. |

| `search_memory` | Utilise `VectorIndexRetriever` pour trouver des souvenirs liés à la mémoire à long terme. |

L'agent planificateur utilise une stratégie d'incitation spéciale pour créer des plans à long terme pour résoudre les problèmes.

L'agent reçoit ses paires action-observation précédentes, la tâche actuelle, et un indice basé sur la dernière action effectuée à chaque étape.

`NullAction`,

`CmdRunAction`,

`CmdKillAction`,

`BrowseURLAction`,

`GithubPushAction`,

`FileReadAction`,

`FileWriteAction`,

`AgentRecallAction`,

`AgentThinkAction`,

`AgentFinishAction`,

`AgentSummarizeAction`,

`AddTaskAction`,

`ModifyTaskAction`,

`Observation`,

`NullObservation`,

`CmdOutputObservation`,

`FileReadObservation`,

`AgentRecallObservation`,

| Méthode | Description |

| ---------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

| `__init__` | Initialise un agent avec `llm` |

| `step` | Vérifie si l'étape actuelle est terminée, retourne `AgentFinishAction` si oui. Sinon, crée une incitation de planification et l'envoie au modèle pour inférence, en ajoutant le résultat comme prochaine action. |

| `search_memory` | Pas encore implémenté |

sidebar_position: 4

Voici un aperçu de haut niveau de l'architecture du système. Le système est divisé en deux composants principaux : le frontend et le backend. Le frontend est responsable de la gestion des interactions avec l'utilisateur et de l'affichage des résultats. Le backend est responsable de la gestion de la logique métier et de l'exécution des agents.


Cet aperçu est simplifié pour montrer les principaux composants et leurs interactions. Pour une vue plus détaillée de l'architecture du backend, consultez la section [Architecture du Backend](#backend-architecture-fr).

_**Avertissement**: L'architecture du backend est en cours de développement et est sujette à modifications. Le schéma suivant montre l'architecture actuelle du backend basée sur le commit indiqué dans le pied de page du schéma._


<details>

<summary>Mise à jour de ce Schéma</summary>

<div>

La génération du schéma d'architecture du backend est partiellement automatisée.

Le schéma est généré à partir des annotations de type dans le code en utilisant l'outil py2puml.

Le schéma est ensuite revu manuellement, ajusté et exporté en PNG et SVG.

- Un environnement Python dans lequel opendevin est exécutable

(selon les instructions du fichier README.md à la racine du dépôt)

- [py2puml](https://github.com/lucsorel/py2puml) installé

1. Générez automatiquement le schéma en exécutant la commande suivante depuis la racine du dépôt :

`py2puml opendevin opendevin > docs/architecture/backend_architecture.puml`

2. Ouvrez le fichier généré dans un éditeur PlantUML, par exemple Visual Studio Code avec l'extension PlantUML ou [PlantText](https://www.planttext.com/)

3. Révisez le PUML généré et apportez toutes les modifications nécessaires au schéma (ajoutez les parties manquantes, corrigez les erreurs, améliorez l'agencement).

_py2puml crée le schéma à partir des annotations de type dans le code, donc les annotations de type manquantes ou incorrectes peuvent entraîner un schéma incomplet ou incorrect._

4. Examinez la différence entre le nouveau schéma et le précédent et vérifiez manuellement si les modifications sont correctes.

_Assurez-vous de ne pas supprimer les parties ajoutées manuellement au schéma par le passé et qui sont toujours pertinentes._

5. Ajoutez le hash du commit qui a été utilisé pour générer le schéma dans le pied de page du schéma.

6. Exporte le schéma sous forme de fichiers PNG et SVG et remplacez les schémas existants dans le répertoire `docs/architecture`. Cela peut être fait avec (par exemple [PlantText](https://www.planttext.com/))

</div>

</details>

sidebar_position: 6

Lorsque vous utilisez OpenDevin, vous rencontrerez sans aucun doute des cas où les choses fonctionnent bien et d'autres où elles ne fonctionnent pas. Nous vous encourageons à fournir des commentaires lorsque vous utilisez OpenDevin pour aider l'équipe de développement et, peut-être plus important encore, créer un corpus ouvert d'exemples de formation pour les agents de codage -- Partagez-OpenDevin !

Fournir des commentaires est simple ! Lorsque vous utilisez OpenDevin, vous pouvez appuyer sur le bouton de pouce vers le haut ou vers le bas à n'importe quel moment de votre interaction. Vous serez invité à fournir votre adresse email (par exemple, afin que nous puissions vous contacter si nous voulons poser des questions de suivi), et vous pouvez choisir si vous souhaitez fournir des commentaires publiquement ou en privé.

<iframe width="560" height="315" src="https://www.youtube.com/embed/5rFx-StMVV0?si=svo7xzp6LhGK_GXr" title="Lecteur vidéo YouTube" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>

* Les données **publiques** seront distribuées sous la licence MIT, comme OpenDevin lui-même, et pourront être utilisées par la communauté pour former et tester des modèles. Évidemment, les commentaires que vous pouvez rendre publics seront plus précieux pour la communauté dans son ensemble, donc lorsque vous ne traitez pas d'informations sensibles, nous vous encourageons à choisir cette option !

* Les données **privées** ne seront partagées qu'avec l'équipe OpenDevin dans le but d'améliorer OpenDevin.