Guide

Embedchain, ou ce qu'un projet abandonné nous apprend

Embedchain n'est plus développé depuis mars 2025 et son dépôt est devenu Mem0. Voici ce qui s'est passé, comment migrer et quoi utiliser à la place pour le RAG.

L'équipe CodeWorlds14 min de lecture ·

Pratique Python dans des leçons interactives avec un éditeur de code.

Crée un compte gratuit→
Dans cet article9

Commençons par le plus important, car cela te fait gagner une soirée de travail. Le développement d'Embedchain est terminé : la dernière version, 0.1.128, date de mars 2025, et le code a disparu du dépôt, qui porte désormais le nom de Mem0 et résout un autre problème. L'ancienne adresse du dépôt redirige là-bas.

Si tu cherches une bibliothèque pour un nouveau projet, ce n'est pas le bon choix et tu peux passer directement à la section sur les alternatives. Si tu as du code qui fonctionne sur Embedchain, ce qui suit décrit ce qui s'est réellement passé et à quoi ressemble la suite.

Ce que faisait le projet

Embedchain est apparu à une époque où construire une recherche sur ses propres documents signifiait assembler plusieurs couches à la main : charger les fichiers, les découper en fragments, calculer les vecteurs, les stocker dans une base de données et relier la requête à un modèle de langage.

La proposition était simple et efficace. Toute cette chaîne tenait en quelques lignes, et les valeurs par défaut étaient raisonnables, donc un premier prototype fonctionnel prenait un quart d'heure au lieu de deux jours.

Python
from embedchain import App

app = App()
app.add("https://example.com/documentation")
app.add("./contract.pdf")

print(app.query("What is the notice period?"))

La valeur se trouvait dans ce qui n'est pas visible ici. La reconnaissance du type de source, le chargement du contenu, le découpage en fragments, le choix du modèle d'embeddings, la configuration de la base vectorielle et l'assemblage du prompt se faisaient sans une ligne de configuration. Pour quelqu'un qui teste une idée plutôt que de construire une infrastructure, c'était une vraie économie.

La bibliothèque gérait une douzaine de types de sources : pages web, fichiers PDF, documents texte, chaînes vidéo, dépôts de code et bases de données. Les modèles de langage et les stockages vectoriels étaient eux aussi interchangeables, y compris les options présentées dans les textes sur Chroma et Qdrant.

Pourquoi le projet s'est arrêté

La raison ne tient ni à des défauts ni à un manque d'intérêt, mais à un déplacement du problème qui vaut la peine d'être résolu.

La recherche dans les documents est devenue une fonctionnalité plutôt qu'un produit. Les modèles de langage ont gagné des fenêtres de contexte qui se comptent en centaines de milliers de tokens, donc pour de nombreux usages, déposer un document directement dans le prompt s'est révélé plus simple que de maintenir une base vectorielle séparée. Pendant ce temps, de grandes bibliothèques, dont LangChain, couvraient le même terrain et ajoutaient tout le reste dont la production a besoin.

La couche de simplification est tombée dans un piège classique. Elle est pratique tant que tu fais exactement ce que l'auteur avait prévu, et dès que tu dois changer la façon dont le texte est découpé ou ajouter ton propre filtrage par métadonnées, l'abstraction commence à gêner. Les projets de cette catégorie soit deviennent de vrais frameworks, soit perdent leur raison d'être.

Les auteurs ont pris une troisième voie et sont passés à un autre problème. Au lieu de se demander comment trouver un fragment de document, ils se sont demandé comment une application devrait se souvenir d'une conversation avec un utilisateur d'une session à l'autre. Mem0 en est issu, et c'est un changement de direction plutôt qu'une nouvelle version de la même chose.

En quoi il diffère de son successeur

Cette distinction mérite d'être comprise, car de l'extérieur les deux outils se ressemblent : chacun stocke du texte, calcule des vecteurs et retrouve ensuite quelque chose.

La recherche dans des documents opère sur un ensemble donné à l'avance qui change rarement. Tu charges les documents une fois, et une requête trouve les fragments correspondants parmi eux. Le savoir est extérieur à la conversation.

Une couche de mémoire opère sur ce que l'utilisateur a dit et change à chaque énoncé. Tu ne stockes pas toute la conversation mais les conclusions qu'on en tire : préférences, faits sur la personne, décisions. Un modèle de langage participe à l'écriture, car il décide ce qui, dans un énoncé, mérite d'être conservé et ce qui invalide une entrée antérieure.

Trois conséquences pratiques. D'abord, la mémoire a besoin d'être mise à jour et pas seulement complétée, car une nouvelle information contredit parfois l'ancienne. Ensuite, écrire coûte un appel au modèle, ce qui est plus cher que de calculer un vecteur. Enfin, les données appartiennent à une personne, ce qui entraîne des exigences de suppression et de confidentialité que la recherche dans la documentation d'une entreprise ne porte pas.

À quoi ressemble la migration

Il n'y a pas de convertisseur automatique ici, car les interfaces diffèrent au niveau des concepts et non des noms de fonctions. L'ampleur du travail dépend de ce pour quoi tu utilisais la bibliothèque.

Si tu avais construit une recherche sur un ensemble fixe de documents, le successeur n'est pas la bonne cible. Passer à l'une des bibliothèques matures, ou écrire cette couche toi-même, est plus logique, car cela représente aujourd'hui quelques dizaines de lignes de code.

Si tu avais construit un assistant censé se souvenir de l'utilisateur d'une session à l'autre, le passage a du sens et ressemble davantage à l'écriture d'une nouvelle couche qu'à la traduction d'une ancienne.

Python
from mem0 import Memory

memory = Memory()
memory.add("I work in the Europe/Warsaw time zone", user_id="anna")

context = memory.search("time zone", filters={"user_id": "anna"})

La plus grande différence lors de la réécriture concerne le moment où tu écris quelque chose. Dans l'ancien montage, tu chargeais les documents au démarrage et ensuite tu ne faisais que poser des questions. Dans le nouveau, l'écriture a lieu pendant la conversation, après chaque tour, et la recherche s'exécute avant l'appel au modèle pour ajouter du contexte au prompt.

Une troisième voie, la plus souvent oubliée, est d'abandonner la bibliothèque. Si tu n'utilisais que le flux de base, ta propre implémentation au-dessus d'une base vectorielle et d'un client de modèle laisse moins de code à maintenir qu'une dépendance dont le cycle de vie vient de s'achever.

Quoi utiliser à la place dans un nouveau projet

OptionPoint fortFaiblesseÀ choisir quand
Mem0Mémoire de conversation, mise à jour des entréesUn problème différent de la recherche de documentsUn assistant qui se souvient de l'utilisateur
LangChainPérimètre le plus large, nombreuses intégrationsAbstraction lourde, nombreux conceptsUn flux complexe avec de nombreuses étapes
LlamaIndexVisé précisément sur les documentsPortée plus étroite au-delà de la rechercheRecherche dans son propre ensemble de documents
Ta propre implémentationZéro dépendance, contrôle totalTu écris toutUn flux simple, un seul type de source

La dernière ligne mérite plus d'attention qu'elle n'en reçoit d'habitude. La recherche de base dans des documents revient aujourd'hui à découper le texte, appeler un modèle d'embeddings, écrire dans une base et interroger avec le contexte joint. Cela tient en cent lignes que tu comprends entièrement et qui ne cesseront pas de fonctionner quand quelqu'un archivera un dépôt.

Le choix entre la deuxième et la troisième ligne dépend du périmètre. Si tu as besoin d'outils, d'agents et de nombreuses étapes au-delà de la recherche, la bibliothèque plus large l'emporte. S'il ne s'agit que de documents, l'outil plus étroit te laisse moins de concepts à apprendre.

La première ligne résout un autre problème et il vaut mieux le régler avant de migrer, car la mémoire de conversation ne remplace pas la recherche de documents. Si la mémoire était le vrai objectif, Letta va plus loin dans cette direction, avec un agent qui modifie ses propres blocs de mémoire en appelant des outils. Il porte sa propre variante de la même histoire : en juillet 2026, les auteurs ont décrit le serveur Python comme déprécié et maintenu seulement en cas d'urgence, en déplaçant le développement vers un paquet installé depuis npm.

Ta propre couche en pratique

Puisque la réponse la plus courante à la fermeture d'une bibliothèque est de l'écrire soi-même, il vaut la peine de montrer combien de travail cela représente vraiment.

Python
import chromadb
from openai import OpenAI

client = OpenAI()
store = chromadb.PersistentClient(path="./data")
collection = store.get_or_create_collection("documents")

def vector(text: str) -> list[float]:
    response = client.embeddings.create(
        model="text-embedding-3-small",
        input=text,
    )
    return response.data[0].embedding

def add(chunks: list[str], source: str) -> None:
    collection.add(
        ids=[f"{source}-{i}" for i in range(len(chunks))],
        embeddings=[vector(c) for c in chunks],
        documents=chunks,
        metadatas=[{"source": source} for _ in chunks],
    )

def ask(question: str) -> str:
    hits = collection.query(query_embeddings=[vector(question)], n_results=5)
    context = "\n\n".join(hits["documents"][0])
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": "Answer strictly from the context."},
            {"role": "user", "content": f"Context:\n{context}\n\nQuestion: {question}"},
        ],
    )
    return response.choices[0].message.content

C'est en gros tout le flux de base, en laissant de côté le découpage du texte en fragments, qui ajoute une douzaine de lignes ou un appel à une bibliothèque prête à l'emploi. Une trentaine de lignes de code au lieu d'une dépendance à l'avenir incertain.

Le gain ne se trouve pas dans le nombre de lignes, cependant, mais dans le fait que chaque décision est visible. Tu sais quel modèle d'embeddings calcule les vecteurs, combien de fragments arrivent dans le prompt, et comment est rédigée exactement l'instruction système. Avec une bibliothèque intermédiaire, ces trois choses sont cachées, et ce sont précisément elles qui décident de la qualité des réponses et de la facture.

Cela montre aussi où se situent les vrais points de réglage. Le nombre de fragments renvoyés pousse le coût et la précision dans des directions opposées. Les métadonnées permettent de restreindre la recherche à une seule source. L'instruction système décide si le modèle admet son ignorance ou comble lui-même le vide. Aucun de ces choix ne peut être fait à l'avance, car ils dépendent de tes documents.

Il y a deux endroits où recourir à quelque chose de prêt vaut la peine. Le premier est le chargement de formats exotiques, où écrire son propre code n'en vaut pas la peine. Le second est celui des flux avec de nombreuses étapes et outils, où l'assemblage à la main commence à ressembler à la construction d'un framework.

Une chose dans ce code mérite l'attention dès le départ, car la corriger plus tard est pénible. Calculer les vecteurs un fragment à la fois fonctionne avec dix documents et devient inacceptable avec mille. Les modèles d'embeddings acceptent plusieurs textes dans un seul appel, donc le traitement par lots réduit le temps d'indexation de plusieurs fois et diminue le nombre de requêtes vers le service. C'est l'optimisation la plus simple de tout ce flux et la plus souvent omise, car la différence est invisible sur un premier prototype.

Ce que cette histoire enseigne

La fermeture d'un projet est un événement ordinaire dans cet écosystème plutôt qu'une exception, donc il vaut la peine d'en tirer des conclusions pour l'avenir.

La première concerne les couches de simplification. Une bibliothèque dont toute la valeur consiste à ramener quinze lignes à trois est fragile par conception. Une fois que la tâche sous-jacente devient plus simple ou qu'un projet plus grand l'absorbe, la couche perd sa raison d'être. Ce n'est pas un reproche aux auteurs mais une propriété prévisible de tels outils.

La deuxième concerne la dépendance aux abstractions. Un code qui appelle directement une base vectorielle et un modèle de langage survit à la fermeture de n'importe quel projet intermédiaire. Un code construit autour de l'objet central de quelqu'un d'autre doit être réécrit.

La troisième concerne l'évaluation d'une dépendance avant de l'ajouter. Vérifie la date du dernier changement, le nombre de personnes ayant un accès en écriture, et si une entreprise se tient derrière le projet, et dans ce cas si le projet est cette entreprise ou seulement sa sortie annexe. Les réponses à ces questions en disent plus que le nombre d'étoiles.

La quatrième est optimiste. Le code archivé ne disparaît pas, donc un projet qui fonctionne sur des versions figées continuera de fonctionner. Le risque concerne les correctifs de sécurité et la compatibilité avec les nouvelles versions des dépendances plutôt que la disparition soudaine d'une bibliothèque.

Si tu fais tourner un tel déploiement en production, trois étapes suffisent pour cesser de t'en inquiéter. Fige les versions exactes de chaque dépendance, y compris transitives, car ce sont elles qui cassent le plus souvent un projet non maintenu. Écris dans le dépôt une note indiquant clairement que la bibliothèque n'est plus maintenue et pourquoi elle est encore là, car personne ne s'en souviendra dans un an. Isole les appels à la bibliothèque derrière ta propre interface couvrant deux opérations : ajouter un document et interroger. Cette troisième étape prend un après-midi et transforme une future migration de réécriture de l'application en remplacement d'un seul fichier.

Il vaut aussi la peine de se programmer un rappel pour vérifier tous les quelques mois les avis de sécurité de cette dépendance. Un projet non maintenu ne recevra pas de correctif, mais connaître un problème te permet d'agir plus tôt que le jour où quelqu'un l'exploite.

Erreurs courantes

La première est de démarrer un nouveau projet sur une bibliothèque abandonnée parce qu'elle était bien classée dans la recherche. La date de la dernière version en dit plus que la position dans les résultats.

La deuxième est de traiter le successeur comme une version rétrocompatible. C'est un outil pour un autre problème, donc la migration est la réécriture d'une couche plutôt qu'un échange d'imports.

La troisième est de transférer la recherche de documents dans une couche de mémoire. Stocker une documentation statique via un mécanisme conçu pour des faits changeants sur un utilisateur coûte des appels au modèle et ne rapporte rien.

La quatrième est de laisser les versions des dépendances non figées. Sur un projet non maintenu, chaque mise à jour d'une bibliothèque voisine peut le casser, et personne ne le réparera.

La cinquième est de tout migrer d'un coup. Il est plus logique d'isoler d'abord l'accès à la recherche derrière ta propre interface, puis de remplacer l'implémentation en dessous.

La sixième est d'éluder la question de savoir si la bibliothèque est nécessaire. Avec un seul type de source et un flux simple, ton propre code est souvent plus court que la configuration de celui de quelqu'un d'autre.

FAQ

Embedchain fonctionne-t-il encore ?

Oui, le paquet se trouve toujours dans le registre PyPI, s'installe et s'exécute, et les projets existants sur des versions figées continuent de fonctionner. Le développement s'est toutefois arrêté à la version 0.1.128 en mars 2025, et le code a disparu du dépôt, donc aucun correctif ni prise en charge des nouvelles versions de dépendances n'est à attendre.

Mem0 est-il une nouvelle version d'Embedchain ?

Pas au sens de la compatibilité. Mem0 est issu du même projet et de la même organisation, tout en résolvant un autre problème : se souvenir d'une conversation avec un utilisateur plutôt que chercher dans un ensemble fixe de documents. Les interfaces diffèrent, donc le passage revient à écrire une nouvelle couche.

Qu'est-ce qui le remplace pour la recherche de documents ?

Cela dépend du périmètre. Pour un flux simple, ta propre implémentation au-dessus d'une base vectorielle fait une centaine de lignes sans aucune dépendance. Pour un flux complexe, des bibliothèques matures comme LangChain ou LlamaIndex ont plus de sens.

Faut-il migrer si tout fonctionne ?

Pas immédiatement. Un système qui fonctionne sur des versions figées peut être laissé tel quel et le passage planifié tranquillement. Il vaut la peine d'isoler l'accès à la recherche derrière ta propre interface, car cela transforme une future migration de réécriture de l'application en remplacement d'un seul module.

Comment savoir si une bibliothèque a un avenir ?

Regarde la date de la dernière version, le nombre de personnes ayant un accès en écriture et le rythme de fermeture des issues. Vérifie aussi si le projet est le produit principal d'une entreprise ou une sortie annexe, car la seconde disparaît plus souvent. Le nombre d'étoiles ne dit rien de la maintenance.

L'histoire du projet est documentée dans le dépôt Mem0, et la documentation du successeur se trouve sur le site du projet.

À lire aussi