Haystack : le framework open source pour des pipelines RAG et agents LLM prêts pour la production

TL;DR

Source principale : deepset-ai/haystack (GitHub) — docs associées : haystack.deepset.ai

Haystack est un framework d’orchestration LLM open source écrit en Python, conçu pour construire des applications de RAG et des agents prêts pour la production. Il organise votre application autour de trois concepts — Composants (Components), Pipelines et Agents — avec un contrôle explicite sur la récupération, le routage, la mémoire et la génération. La version 3.0 introduit les Agent Hooks, les Skills et un cœur allégé. Cet article décortique le repo officiel : concepts, code réel (pipeline RAG + agent), écosystème et cas d’usage.

Au programme

Haystack, c’est quoi exactement ?
Le problème que Haystack résout : le contexte
Les concepts clés : Components, Pipelines, Agents
Installation et premiers pas
Construire un pipeline RAG pas à pas
Passer aux agents dans Haystack 3.0
L’écosystème et les intégrations
Comparaison : quand utiliser Haystack ?
FAQ
Liens utiles
Conclusion

Haystack, c’est quoi exactement ?

Haystack est le framework d’IA open source développé par deepset GmbH pour construire des applications LLM prêtes pour la production. Sa définition officielle, telle qu’annoncée dans le README du repo :

"The Open Source AI Framework for Production Ready RAG & Agents"

Concrètement, Haystack est un framework d’orchestration : il ne remplace ni le LLM ni le modèle d’embedding, il orchestre. Il vous permet de concevoir des pipelines modulaires et des workflows d’agents avec un contrôle explicite sur quatre briques fondamentales :

la récupération (retrieval),
le routage (routing),
la mémoire (memory),
la génération (generation).

Avec Haystack, vous pouvez construire des systèmes :

de RAG (Retrieval-Augmented Generation),
d’agents scalables,
de recherche sémantique,
d’applications multimodales,
de systèmes conversationnels.

Le point fort revendiqué par l’équipe : Haystack est livré pré-configuré avec les meilleurs modèles et intégrations disponibles, ce qui évite de perdre du temps à recâbler l’écosystème à la main. Vous vous concentrez sur votre logique métier, pas sur l’intégration de dizaines de SDK.

Pour qui ? Data scientists, ingénieurs ML et développeurs Python qui veulent passer d’un prototype Jupyter à une application de production — avec déploiement en self-hosted (FastAPI, LangServe, vLLM, Ollama, LocalAI) ou en cloud.

Le problème que Haystack résout : le contexte

Un LLM nu ne connaît que ce qu’il a appris à l’entraînement. Dès que vous voulez répondre à partir de vos documents, de vos bases de données ou de vos API, il faut lui fournir du contexte au moment de la requête. C’est ce qu’on appelle l’ingénierie de contexte (context engineering).

Le vrai sujet d’un système RAG n’est pas « appeler un LLM », c’est :

où récupérer l’information pertinente (base vectorielle, index BM25, API externe…),
comment formater un prompt exploitable avec les documents récupérés,
quand récupérer plus, router vers un outil, ou répondre directement,
comment garder la mémoire d’une conversation multi-tours.

Haystack structure cette complexité. Au lieu d’un script monolithique, vous décrivez un graphe de composants où chaque nœud fait une seule chose. Le framework se charge de la validation, de l’exécution, de la sérialisation et de la visualisation.

Les concepts clés : Components, Pipelines, Agents

Haystack repose sur trois concepts centraux.

Components (composants)

Un Component est la brique de base : une classe Python avec une méthode run(), qui a des entrées et des sorties typées. Exemples : un retriever, un générateur, un convertisseur HTML, un embedder, un écrivain de documents.

Découvrez Temporal : introduction complète à la durable execution pour des workflows qui survivent aux crashs

La règle d’or : un composant = une responsabilité. C’est ce qui rend les pipelines débuggables et testables.

Pipelines

Un Pipeline assemble des composants en un graphe orienté. Vous définissez les nœuds (add_component) et les arêtes (connect). Le pipeline :

valide les types de connexions (une sortie ne peut pas se brancher sur une entrée incompatible),
expose .inputs() pour lister les entrées obligatoires/optionnelles,
sait se sérialiser en YAML et se visualiser (export Mermaid) pour l’audit,
supporte le branching (embranchements), les boucles et l’exécution asynchrone.

Agents

Les Agents sont le niveau d’abstraction supérieur : un agent orchestre des outils et prend des décisions de routage de façon autonome (souvent piloté par le LLM lui-même). Haystack fournit des agents pré-construits (agent RAG, agent de recherche web…) et des primitives pour construire les vôtres.

Installation et premiers pas

L’installation se fait via PyPI. Deux paquets distincts selon le besoin :

# Haystack "cœur" : pip install haystack-ai
pip install haystack-ai

# Les intégrations sont installées séparément,
# par ex. les embedders SentenceTransformers (utilisés plus bas) :
pip install sentence-transformers-haystack

Pourquoi haystack-ai et pas haystack ? Le paquet haystack sur PyPI est l’ancien nom (réservé à l’écosystème 1.x/2.x). Le développement actif vit dans haystack-ai. Ne les confondez pas !

Prérequis : Python 3.10+ (à vérifier selon la version), une clé API pour le LLM de votre choix (OpenAI par défaut dans les exemples officiels, mais tout est interchangeable).

Construire un pipeline RAG pas à pas

Voici le pipeline RAG officiel de la documentation (v3.0), que je décortique étape par étape. Objectif : répondre à une question en s’appuyant sur des documents indexés.

1. Les imports

from haystack import Pipeline, Document
from haystack.components.generators.chat import OpenAIChatGenerator
from haystack.components.retrievers import InMemoryBM25Retriever
from haystack.document_stores.in_memory import InMemoryDocumentStore
from haystack.components.builders import ChatPromptBuilder
from haystack.utils import Secret
from haystack.dataclasses import ChatMessage

On importe : le Pipeline, le modèle Document, un retriever BM25 (recherche lexicale), un générateur de chat OpenAI, un prompt builder, le Document Store en mémoire et le gestionnaire de secrets.

2. Le store de documents

document_store = InMemoryDocumentStore()
document_store.write_documents(
    [
        Document(content="My name is Jean and I live in Paris."),
        Document(content="My name is Mark and I live in Berlin."),
        Document(content="My name is Giorgio and I live in Rome."),
    ],
)

Le Document Store centralise vos documents et leurs métadonnées. Ici, en mémoire pour la démo ; en production on branchera MongoDB, Qdrant, Pinecone, PostgreSQL/pgvector… via les intégrations.

3. Le template de prompt (Jinja)

prompt_template = [
    ChatMessage.from_system(
        """
        Given these documents, answer the question.
        Documents:
        {% for doc in documents %}
            {{ doc.content }}
        {% endfor %}
        Question:
        """,
    ),
    ChatMessage.from_user("{{question}}"),
    ChatMessage.from_system("Answer:"),
]

prompt_builder = ChatPromptBuilder(template=prompt_template, required_variables="*")

Haystack utilise Jinja2 pour les templates : les variables {{ ... }} sont injectées dynamiquement. required_variables="*" force la présence de toutes les variables à l’exécution.

4. Les composants

retriever = InMemoryBM25Retriever(document_store=document_store)

llm = OpenAIChatGenerator(
    api_key=Secret.from_env_var("OPENAI_API_KEY"),
    model="gpt-4o-mini",
)

Notons le Secret Management : la clé API n’est pas en dur dans le code, elle est lue depuis la variable d’environnement OPENAI_API_KEY.

5. L’assemblage du pipeline

rag_pipeline = Pipeline()
rag_pipeline.add_component("retriever", retriever)
rag_pipeline.add_component("prompt_builder", prompt_builder)
rag_pipeline.add_component("llm", llm)

rag_pipeline.connect("retriever", "prompt_builder.documents")
rag_pipeline.connect("prompt_builder", "llm")

Trois nœuds, deux arêtes. La syntaxe connect("source", "destination.entree") permet de préciser l’entrée exacte quand le composant en possède plusieurs.

6. L’exécution

question = "Who lives in Paris?"
results = rag_pipeline.run(
    {
        "retriever": {"query": question},
        "prompt_builder": {"question": question},
    },
)
print(results["llm"]["replies"])

Le pipeline va : récupérer les documents pertinents → injecter le contexte dans le prompt → appeler le LLM → retourner la réponse.

Ce qu’on apprend de cet exemple : la structure est simple mais exprime déjà le contrat central de Haystack — chaque composant a des entrées/sorties typées, les connexions sont validées, et run() reçoit un dict {composant: {entrée: valeur}}.

Pour aller plus loin

.inputs() : liste les entrées obligatoires de chaque composant avant de lancer le pipeline.
draw() : exporte le pipeline en graphe Mermaid pour la documentation et la revue.
Sérialisation YAML : pipe.dumps() / pipe.loads() pour versionner vos pipelines comme du code.
Boucles et breakpoints : les pipelines peuvent itérer et être débuggés pas à pas.

Découvrez T3MP3ST : un framework multi-agent pour le red teaming autorise

Passer aux agents dans Haystack 3.0

Avec la version 3.0, Haystack passe à la vitesse supérieure côté agents. Le quick-start officiel montre un Agent RAG complet en quelques lignes.

L’Agent RAG du quick-start

import os
from haystack import Agent
from haystack.components.tools import ComponentTool
from haystack.dataclasses import ChatMessage
from haystack.document_stores.in_memory import InMemoryDocumentStore
from haystack.components.retrievers import InMemoryBM25Retriever

os.environ["OPENAI_API_KEY"] = "sk-..."

# 1. On prépare le store et le retriever
document_store = InMemoryDocumentStore()
document_store.write_documents(...)

retriever = InMemoryBM25Retriever(document_store=document_store)

# 2. On expose le retriever comme un OUTIL de l'agent
rag_tool = ComponentTool(
    name="retriever",
    description="Retrieve relevant documents from the store",
    component=retriever,
)

# 3. L'agent décide lui-même quand utiliser l'outil
agent = Agent(
    component_tools=[rag_tool],
    system_prompt="You are a helpful assistant that answers questions.",
)

agent.run("What is Haystack?")

La différence majeure avec un pipeline : ici, c’est le LLM qui décide d’appeler ou non le retriever, selon la question posée. Le composant est enveloppé dans un ComponentTool — c’est le mécanisme qui expose un composant Haystack comme outil appelable par l’agent.

Les nouveautés de la 3.0

Agent Hooks : des points d’accroche pour injecter une logique personnalisée aux différentes étapes du cycle de vie d’un agent (avant/après appel LLM, avant/après un appel d’outil…).
Skills : des primitives réutilisables qui encapsulent des comportements d’agent complets.
Un cœur allégé : moins de dépendances par défaut, des performances améliorées, un code plus simple à maintenir.
Agents pré-construits : des agents prêts à l’emploi (RAG, recherche web…) que vous personnalisez plutôt que de repartir de zéro.
Mock components : simuler des composants en phase de développement/tests sans effectuer d’appels réseau.
Un chemin de migration documenté depuis la 2.x (la majeure partie du code est rejouable, mais vérifiez les changements d’API dans les notes de version).

L’écosystème et les intégrations

La puissance de Haystack vient autant de son cœur que de son écosystème d’intégrations, distribuées sous forme de paquets séparés (haystack-core-integrators, etc.) :

Domaine	Exemples d’intégrations
Stores de documents	InMemory, MongoDB, Qdrant, Pinecone, Weaviate, Chroma, PostgreSQL (pgvector)
Modèles d’embedding	SentenceTransformers, OpenAI, Cohere, Hugging Face
Générateurs LLM	OpenAI, Anthropic, Cohere, Mistral, Ollama, Hugging Face, vLLM, LocalAI
Serveurs / déploiement	FastAPI, LangServe, Gradio
Extraction de documents	HTML, PDF, DOCX, markdown, via convertisseurs dédiés

Cette séparation en paquets installables à la demande garde le cœur léger : vous n’installez que ce dont vous avez besoin.

Utilisé en production par (listé dans le README) : une centaine d’organisations à travers les secteurs, et des produits comme Foretold, Carevoice, Klar ou encore la recherche web de serper.dev — sans compter l’adoption massive du côté open source (des milliers de stars et un écosystème de tutoriels/cookbooks).

Comparaison : quand utiliser Haystack ?

Critère	Haystack (deepset)	Frameworks généralistes (LangChain, LlamaIndex)
Philosophie	Pipelines modulaires + agents, typage strict	Abstractions larges, beaucoup de chaînages
Maturité production	Cœur stabilisé, tests, sérialisation YAML, hooks	Large écosystème mais surface d’API changeante
Contrôle	Explicite (entrées/sorties typées, validation)	Parfois magique
Courbe d’apprentissage	Modérée, concepts peu nombreux	Variable selon le framework

Utilisez Haystack si vous voulez du contrôle explicite, une architecture de pipeline auditée et un framework conçu dès le départ pour la mise en production (sérialisation, gestion des secrets, device management, intégrations serveur).

Préférez autre chose si vous cherchez un framework déjà tout intégré avec des centaines de fournisseurs en un seul paquet, ou si votre cas d’usage très simple n’a pas besoin d’orchestration.

FAQ

Q : Haystack est-il gratuit ? Le framework est open source (licence Apache-2.0). deepset monétise séparément une plateforme hébergée (deepset Cloud / Studio) et du support entreprise.

Q : Quelle est la différence entre haystack et haystack-ai ? haystack est l’ancien paquet (1.x/2.x). haystack-ai est le paquet actif. Installez pip install haystack-ai.

Q : Faut-il un GPU ? Non pour le cœur. Les embedders peuvent tourner en local (CPU) ou être hébergés (API). Les LLM sont le plus souvent appelés via API, ou via Ollama/vLLM si vous avez du matériel.

Q : Puis-je utiliser Haystack sans OpenAI ? Oui, totalement. Générateurs et embedders sont interchangeables : Mistral, Anthropic, Cohere, Hugging Face, Ollama, LocalAI…

Q : Haystack est-il adapté aux agents, pas seulement au RAG ? Oui, la 3.0 place les agents au centre : Agent Hooks, Skills, agents pré-construits, ComponentTool pour exposer n’importe quel composant comme outil.

Liens utiles

Repo GitHub : https://github.com/deepset-ai/haystack
Documentation : https://docs.haystack.deepset.ai
Tutoriels : https://haystack.deepset.ai/tutorials
Cookbooks : https://haystack.deepset.ai/cookbook
Intégrations : https://haystack.deepset.ai/integrations
Site de deepset : https://deepset.ai

Conclusion

Haystack est un excellent choix si vous voulez construire des systèmes RAG et des agents LLM avec une architecture propre, modulaire et pensée pour la production. Les concepts sont peu nombreux (Composants, Pipelines, Agents), le typage est strict, la sérialisation YAML vous permet de versionner vos pipelines, et la 3.0 apporte les agents de nouvelle génération (hooks, skills, outils) sans gonfler le cœur du framework.

Pour aller plus loin : installez haystack-ai, lancez le pipeline RAG de cet article, puis remplacez le InMemoryBM25Retriever par un retriever vectoriel sur MongoDB ou Qdrant — vous aurez déjà une base de production solide.

Si vous avez testé Haystack ou construit un agent avec, partagez votre expérience en commentaire !

Transparence IA

Ce contenu a été partiellement rédigé ou structuré avec l aide d outils d intelligence artificielle, puis relu, corrigé et complété par l auteur avant publication.