Un agent IA peut utiliser un excellent modele et echouer parce que son contexte decrit la realite d’hier.
Le pipeline RAG classique lit un corpus, le decoupe, genere des embeddings et ecrit un index. Cela suffit pour une demo. En production, les fichiers changent, le code de transformation evolue, les schemas bougent et les donnees arrivent en continu. Tout reconstruire gaspille du calcul ; reconstruire selon un horaire laisse un delai de fraicheur.
CocoIndex traite ce probleme avec un moteur de donnees incremental pour workloads IA. Vous decrivez la cible souhaitee en Python ; CocoIndex la synchronise avec les sources et le code en ne recalculant que le delta affecte. Le projet est open source sous Apache-2.0, expose une API Python et utilise un coeur Rust.
La premiere mise a jour lit la source, execute les transformations et cree la cible avec lignage et empreintes.
Seuls les enregistrements modifies et leurs descendants sont recalcules. Les chunks inchanges conservent leurs embeddings.
CocoIndex suit les versions des transformations et recalcule les sorties affectees sans reconstruire aveuglement chaque cible.
Ce qu’est CocoIndex
CocoIndex est un framework persistant de transformation incrementale, pas une nouvelle base vectorielle. Il relie sources, transformations et cibles, suit dependances et lignage, puis maintient le resultat declare dans le temps.
Son expression centrale est :
Cible = F(Source)
Vous ecrivez F en Python. CocoIndex derive le graphe de traitement, calcule les empreintes des entrees et du code, planifie le travail en parallele et reconcilie la cible. Le modele rappelle React : decrire le resultat voulu et laisser le moteur mettre a jour le minimum d’etat affecte.
Les sources peuvent inclure fichiers locaux, S3, Google Drive, bases, Kafka et autres queues. Les cibles comprennent Postgres, Qdrant, LanceDB, SQLite, Neo4j, FalkorDB, SurrealDB, Turbopuffer et des systemes de streaming. Les transformations peuvent decouper du texte, creer des embeddings, appeler des LLM, resoudre des entites ou construire des structures metier.
Pourquoi l’incremental est important
Imaginez un paragraphe modifie dans un document parmi 100 000 fichiers. Un indexeur batch peut rescanner le corpus et regenerer trop d’embeddings. Un job horaire peut attendre avant de le faire.
CocoIndex suit les valeurs derivees qui dependent de l’entree modifiee. Le fichier est relu, ses chunks compares et seul le travail downstream affecte est execute. Une fonction d’embedding memoisee reutilise son resultat lorsque son entree et son implementation n’ont pas change.
Le meme principe vaut lorsque le code evolue. Les versions du code participent a l’invalidation, ce qui permet de mettre a jour les sorties concernees. La cible reste disponible pendant la reconciliation, sans imposer un remplacement complet d’index.
Le benefice ne se limite pas a la vitesse : moins d’appels aux embeddings et LLM, moins de latence de fraicheur et une indexation continue praticable.
Forme minimale d’un flow
L’API v1 emploie des fonctions Python et des lignes cibles declarees :
import cocoindex as coco
@coco.fn(memo=True)
async def index_file(file, table):
text = await file.read_text()
for chunk in split(text):
table.declare_row(text=chunk, embedding=embed(chunk))
@coco.fn
async def main(source):
table = await mount_target()
await coco.mount_each(index_file, source.items(), table)
Les connecteurs varient, mais la conception reste directe : monter sources et cibles, transformer en Python et declarer les lignes attendues. Une execution realise le backfill ; le mode live reagit ensuite aux changements.
Installation officielle :
pip install -U cocoindex
La documentation v1 prend en charge Python 3.11 a 3.13 sur macOS, Linux et Windows. Les connecteurs sont des dependances optionnelles, ce qui permet de n’installer que les integrations necessaires.
Contexte frais pour agents de longue duree
Un agent actif quelques minutes tolere un snapshot. Un agent qui travaille plusieurs jours ou sert de nombreux utilisateurs a besoin d’un contexte qui evolue.
CocoIndex vise ce cas :
- contexte de code frais avec symboles, chunks, appels et recherche semantique ;
- politiques et tickets recents pour un agent support ;
- personnes, decisions et actions de reunion dans un graphe ;
- suivi des changements pour un agent de revue de securite ;
- transformation d’images, videos, voix et transcriptions pour un agent multimodal.
Le projet compagnon CocoIndex Code illustre l’intelligence de code, mais le framework principal reste generaliste.
Lignage et explicabilite
La recherche est difficile a approuver si personne ne sait d’ou vient un vecteur ou une arete. CocoIndex conserve le lignage afin de retracer les valeurs cibles jusqu’aux sources.
On peut ainsi demander : quel fichier et quel chunk ont produit ce vecteur ? Pourquoi cette ligne a-t-elle change ? Quelle version du code l’a creee ? Quel travail a ete mis en cache, retente ou ignore ?
CocoInsight est presente comme la couche visuelle d’observabilite des etapes, enregistrements, debits, fraicheur, reutilisation et lignage. Cela ne rend pas automatiquement une reponse IA correcte, mais rend son chemin de donnees inspectable.
Comparaison avec les alternatives
Face a un script ponctuel : le script reste plus simple pour des donnees petites ou immuables. CocoIndex devient utile quand les sources et le code changent continuellement.
Face a un DAG d’orchestration : CocoIndex laisse ecrire la logique en Python et derive les dependances incrementales. Les orchestrateurs restent utiles a grande echelle, mais travaillent souvent au niveau des jobs ou partitions.
Face a une base vectorielle : la base stocke et recherche des vecteurs. CocoIndex prepare et maintient les donnees dans des cibles vectorielles, relationnelles, graphes et streaming. Ils sont complementaires.
Face au CDC seul : le CDC detecte les mutations de source. CocoIndex suit aussi le code, les fonctions memoisees, les enregistrements derives et la reconciliation de cible.
Compromis operationnels
Un systeme incremental echange la simplicite du batch contre une coordination avec etat. Il faut exploiter l’etat interne, les identifiants, credentials, schemas, processus live et chemins d’echec. Une empreinte correcte ne garantit pas qu’un chunker ou une migration d’embeddings soit semantiquement correct.
Questions a trancher :
- Quelle identite stable utiliser pour chaque source et ligne cible ?
- Quelles fonctions peuvent etre memoisees sans risque ?
- Comment gerer limites, retries, dead letters et echecs partiels ?
- Comment valider une migration de modele ou de schema ?
- Quelles regles de retention et suppression appliquer ?
- Le lignage et les credentials satisfont-ils les contraintes reglementaires ?
« Seulement le delta » peut rester couteux si un changement invalide un large fan-out. Mesurez des mises a jour representatives, pas uniquement le backfill initial.
Quand l’utiliser
CocoIndex convient lorsque les donnees changent souvent, les operations IA sont couteuses, la fraicheur est critique et le contexte derive couvre plusieurs modeles de stockage. Il est adapte au RAG live, a l’intelligence de code, aux graphes de connaissances, a l’indexation multimodale et a la memoire d’agent actualisee.
Il peut etre superflu pour un petit corpus statique, une requete de base sans etat derive ou un pipeline deja bien gere. La valeur operationnelle doit depasser le cout d’un moteur avec etat supplementaire.
Conclusion
L’idee utile de CocoIndex est qu’un pipeline IA doit se comporter comme une vue maintenue, pas comme un script batch jetable. Vous declarez la cible, puis le moteur applique en continu le plus petit changement necessaire lorsque sources et code evoluent.
Pour les agents, le contexte reste frais sans repayer tout le corpus. Pour les ingenieurs, les transformations Python, les connecteurs, le lignage et le coeur Rust constituent un pont entre prototype d’indexation et systeme de donnees durable.
Commencez par un flow et un type de changement mesurable. Validez le delta, inspectez le lignage, mesurez la reutilisation et les couts, puis etendez progressivement la couche de contexte.