Outils IA Open Source Entreprise 2026 : Ollama, LangChain, n8n | Talki Academy

Q: LangChain est-il encore pertinent en 2026 face a LlamaIndex et Haystack ?

LangChain reste le framework le plus adopté (50M+ téléchargements/mois), avec l'ecosystème le plus riche en intégrations. LlamaIndex excelle sur les pipelines RAG purs. Haystack est préféré pour la recherche sémantique enterprise avec Elasticsearch. Pour la plupart des cas d'usage entreprise (chatbot, RAG, agents), LangChain + LangGraph est le choix le plus pragmatique en 2026.

Q: Peut-on faire du RAG avec Ollama sans carte graphique ?

Oui, mais les performances sont réduites. Sur CPU uniquement, des modèles comme Phi-3 Mini (3.8B) ou Llama 3.2 3B fonctionnent de façon acceptable (3-8 secondes par réponse). Pour le RAG, la partie embedding (nomic-embed-text) est légère et tourne bien sur CPU. Si le GPU n'est pas possible, considérez une instance cloud spot avec GPU pour les traitements batch.

Q: n8n est-il gratuit pour une utilisation enterprise ?

n8n propose trois options : self-hosted Community Edition (totalement gratuit, open source), Cloud Starter (EUR 20/mois, 2500 exécutions), et Enterprise (prix sur devis, SLA, SSO, audit logs). Pour la plupart des PME, la version self-hosted sur un VPS à EUR 10-20/mois couvre tous les besoins. Le code est sur GitHub sous licence Apache 2.0 avec une exception Sustainable Use.

Pourquoi l'open source change la donne pour l'IA en entreprise

En 2022, intégrer l'IA dans une entreprise signifiait presque inévitablement passer par OpenAI ou Google. En 2026, la situation a radicalement changé. Des outils open source matures — Ollama, LangChain, n8n — permettent de construire des systèmes IA comparables aux solutions propriétaires, pour une fraction du coût et avec un contrôle total sur les données.

Trois avantages structurels expliquent cette adoption massive :

Coût — Pas de facturation à la requête. Une infrastructure Ollama + LangChain sur un serveur EUR 200/mois remplace une facture API qui pourrait atteindre EUR 2 000-10 000/mois pour un usage intensif.
Confidentialité des données — Les données sensibles ne quittent pas votre infrastructure. Critique pour les secteurs juridique, médical, financier et toute entreprise soumise au RGPD avec des données clients.
Flexibilité — Vous choisissez le modèle, vous le fine-tunez sur vos données, vous le déployez où vous voulez. Aucune dépendance à un fournisseur unique.

Point clé : "Open source" ne signifie pas "moins performant". En 2026, Llama 3.3 70B et Mistral Large 2 rivalisent avec GPT-4o sur la plupart des tâches métier. La différence de performance s'est considérablement réduite.

Ollama : faites tourner des LLM en local

Ollama est un outil qui permet de télécharger et d'exécuter des grands modèles de langage directement sur votre machine ou vos serveurs, sans configuration complexe. Une commande pour installer, une commande pour lancer un modèle.

Installation et premier modèle

# Installation (macOS / Linux)
curl -fsSL https://ollama.com/install.sh | sh

# Télécharger et lancer Llama 3.2 (3B — rapide, léger)
ollama run llama3.2

# Pour des tâches plus complexes : Llama 3.3 70B (nécessite 40GB+ VRAM)
ollama pull llama3.3:70b

# Vérifier les modèles disponibles localement
ollama list

Utilisation depuis Python

Ollama expose une API REST compatible OpenAI. Vous pouvez l'utiliser avec le SDK Python natif ou directement via requests :

# pip install ollama
import ollama

# Requête simple
response = ollama.chat(
    model='llama3.2',
    messages=[{
        'role': 'user',
        'content': (
            'Analyse ce retour client et identifie les points clés : '
            '"Le produit est excellent mais la livraison était lente '
            'et l'emballage était abîmé."'
        )
    }]
)
print(response['message']['content'])
# Points clés : Qualité produit (positif), Délai de livraison (négatif),
#               État de l'emballage (négatif)

# Streaming pour les interfaces utilisateur
for chunk in ollama.chat(
    model='llama3.2',
    messages=[{'role': 'user', 'content': 'Rédige un email professionnel de relance'}],
    stream=True
):
    print(chunk['message']['content'], end='', flush=True)

Modèles recommandés par cas d'usage

Cas d'usage	Modèle recommandé	VRAM requise	Vitesse
Classification, extraction	Phi-3 Mini (3.8B)	4 GB	Très rapide
Chatbot, Q&R documentaire	Llama 3.2 (7B)	8 GB	Rapide
Analyse, génération longue	Mistral Nemo (12B)	16 GB	Moyen
Raisonnement complexe, code	Llama 3.3 (70B)	40 GB	Lent
Embeddings (RAG)	nomic-embed-text	1 GB	Très rapide

LangChain : orchestrez vos pipelines IA

LangChain est le framework Python (et JavaScript) le plus adopté pour construire des applications IA. Il fournit des abstractions pour connecter des LLM à des bases de données, des APIs, des outils externes, et pour orchestrer des séquences d'appels complexes.

Pipeline RAG avec Ollama — exemple complet

Le cas d'usage le plus courant en entreprise : un chatbot qui répond à des questions sur vos documents internes (contrats, politiques RH, documentation produit).

# pip install langchain langchain-community langchain-ollama chromadb pypdf
from langchain_ollama import OllamaLLM, OllamaEmbeddings
from langchain_community.vectorstores import Chroma
from langchain_community.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.chains import RetrievalQA

# 1. Charger vos documents (PDF, DOCX, TXT...)
loader = PyPDFLoader("politique-rh-2026.pdf")
documents = loader.load()

# 2. Découper en chunks (optimise la précision de la recherche)
splitter = RecursiveCharacterTextSplitter(
    chunk_size=800,
    chunk_overlap=100,
    separators=["

", "
", ".", " "]
)
chunks = splitter.split_documents(documents)

# 3. Créer les embeddings et stocker dans ChromaDB (persistant)
embeddings = OllamaEmbeddings(model="nomic-embed-text")
vectorstore = Chroma.from_documents(
    chunks,
    embeddings,
    persist_directory="./chroma_db"  # Persist entre les redémarrages
)

# 4. Créer la chaîne RAG
llm = OllamaLLM(model="llama3.2", temperature=0.1)
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever(search_kwargs={"k": 3}),
    return_source_documents=True
)

# 5. Interroger
result = qa_chain.invoke({
    "query": "Quelle est la politique de télétravail ?"
})
print(result["result"])
# → "Selon notre politique RH 2026, les employés peuvent télétravailler
#    jusqu'à 3 jours par semaine après validation du manager..."

# Les sources utilisées
for doc in result["source_documents"]:
    print(f"Source: page {doc.metadata['page']}")

Astuce : Utilisez temperature=0.1 pour les réponses factuelles sur vos documents. Une température basse réduit les hallucinations et ancre le modèle sur les documents récupérés.

Agents LangChain avec outils

Au-delà du RAG, LangChain permet de créer des agents capables d'utiliser des outils (recherche web, calculs, APIs) pour accomplir des tâches en plusieurs étapes :

from langchain_ollama import OllamaLLM
from langchain.agents import create_react_agent, AgentExecutor
from langchain.tools import tool
from langchain import hub

# Définir des outils métier personnalisés
@tool
def get_product_stock(product_id: str) -> str:
    """Vérifie le stock d'un produit en base de données."""
    # Remplacez par votre vrai appel DB
    stocks = {"PROD-001": 45, "PROD-002": 0, "PROD-003": 120}
    qty = stocks.get(product_id, -1)
    if qty == -1:
        return f"Produit {product_id} introuvable"
    return f"Stock de {product_id} : {qty} unités"

@tool
def calculate_delivery_date(warehouse: str, destination: str) -> str:
    """Calcule la date de livraison estimée."""
    delays = {"Paris": 1, "Lyon": 2, "Marseille": 3, "default": 5}
    days = delays.get(destination, delays["default"])
    return f"Livraison estimée depuis {warehouse} vers {destination} : {days} jours ouvrés"

# Créer l'agent
llm = OllamaLLM(model="llama3.2")
tools = [get_product_stock, calculate_delivery_date]
prompt = hub.pull("hwchase17/react")

agent = create_react_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# L'agent décide lui-même quels outils utiliser
result = executor.invoke({
    "input": "Vérifie si PROD-001 est en stock et donne la date de livraison vers Lyon"
})
print(result["output"])
# → "PROD-001 est en stock (45 unités). Livraison vers Lyon : 2 jours ouvrés."

n8n : automatisez vos workflows IA sans code

n8n est une plateforme d'automatisation open source (alternative à Zapier ou Make) qui se distingue par sa capacité à intégrer des nœuds IA natifs — appels à Ollama, LangChain, ou des APIs LLM — dans des workflows visuels. C'est le "colle" qui connecte vos outils IA à votre écosystème existant (CRM, ERP, email, Slack...).

Installation en 2 minutes

# Option 1 : Docker (recommandé pour la production)
docker run -d   --name n8n   -p 5678:5678   -v ~/.n8n:/home/node/.n8n   -e N8N_BASIC_AUTH_ACTIVE=true   -e N8N_BASIC_AUTH_USER=admin   -e N8N_BASIC_AUTH_PASSWORD=votre_mot_de_passe   n8nio/n8n

# Accéder à l'interface : http://localhost:5678

# Option 2 : npm (développement local)
npm install -g n8n
n8n start

Workflow type : traitement automatique des emails entrants

Voici un workflow n8n réel qui analyse chaque email entrant avec Ollama, le catégorise et crée une tâche dans votre CRM :

Déclencheur — Email reçu (Gmail, Outlook, IMAP)
Nœud HTTP Request — Appel à l'API Ollama locale pour analyser le contenu
Nœud Switch — Route selon la catégorie (urgent / commercial / support)
Nœud CRM — Crée une tâche dans HubSpot / Salesforce / Pipedrive
Nœud Slack — Notifie l'équipe concernée

# Appel à Ollama depuis un nœud HTTP Request de n8n
# URL : http://ollama:11434/api/generate (si Ollama tourne en Docker)
# Méthode : POST
# Body (JSON) :
{
  "model": "llama3.2",
  "prompt": "Catégorise cet email en : URGENT, COMMERCIAL, SUPPORT, SPAM. Email : {{ $json.body }}. Réponds avec juste la catégorie.",
  "stream": false
}

# La réponse est disponible dans le nœud suivant via :
# {{ $json.response }}

n8n peut également déclencher des scripts Python, ce qui permet d'intégrer vos chaînes LangChain directement dans un workflow visuel :

# Nœud "Execute Command" dans n8n
# Déclenche votre script Python avec les données du workflow
python3 /opt/scripts/process_email.py   --subject "{{ $json.subject }}"   --body "{{ $json.body }}"   --sender "{{ $json.from }}"

# Le script retourne un JSON que n8n peut exploiter dans les nœuds suivants

Construire un chatbot support client : Ollama + LangChain + n8n

Voici un chatbot complet et fonctionnel qui combine les trois outils : Ollama pour l'inférence locale, LangChain pour la mémoire de conversation et le RAG sur votre documentation produit, et n8n pour l'intégrer à vos canaux support existants (Slack, Intercom, email).

Étape 1 — Backend Python : chatbot LangChain avec mémoire

# pip install langchain langchain-ollama chromadb fastapi uvicorn pypdf
from langchain_ollama import OllamaLLM, OllamaEmbeddings
from langchain_community.vectorstores import Chroma
from langchain.memory import ConversationBufferWindowMemory
from langchain.chains import ConversationalRetrievalChain
from langchain_community.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

# --- Construction de la base de connaissances au démarrage ---
loader = PyPDFLoader("docs-produit.pdf")
docs = loader.load()
chunks = RecursiveCharacterTextSplitter(chunk_size=600, chunk_overlap=80).split_documents(docs)

embeddings = OllamaEmbeddings(model="nomic-embed-text")
vectorstore = Chroma.from_documents(chunks, embeddings, persist_directory="./support_kb")

llm = OllamaLLM(model="llama3.2", temperature=0.2)

# Mémoires par session (utilisez Redis en production)
sessions: dict[str, ConversationBufferWindowMemory] = {}

def get_chain(session_id: str) -> ConversationalRetrievalChain:
    if session_id not in sessions:
        sessions[session_id] = ConversationBufferWindowMemory(
            memory_key="chat_history",
            return_messages=True,
            k=6  # Conserve les 6 derniers tours de conversation
        )
    return ConversationalRetrievalChain.from_llm(
        llm=llm,
        retriever=vectorstore.as_retriever(search_kwargs={"k": 3}),
        memory=sessions[session_id]
    )

class ChatRequest(BaseModel):
    session_id: str
    message: str

@app.post("/chat")
def chat(req: ChatRequest):
    chain = get_chain(req.session_id)
    result = chain.invoke({"question": req.message})
    return {
        "reponse": result["answer"],
        "session_id": req.session_id
    }

# Lancement : uvicorn chatbot:app --host 0.0.0.0 --port 8000

Étape 2 — n8n : connecter le chatbot à Slack

Ce workflow n8n reçoit une commande Slack, transmet le message au chatbot FastAPI et poste la réponse dans le même fil — sans aucun code dans n8n :

# Workflow n8n : Slack → Chatbot → Slack (4 nœuds, zéro code)

# Nœud 1 : Webhook (déclencheur)
#   Méthode : POST
#   URL : https://votre-n8n.com/webhook/slack-support
#   (À enregistrer comme URL de la slash command Slack)

# Nœud 2 : HTTP Request (appel au chatbot LangChain)
#   Méthode : POST
#   URL : http://chatbot-service:8000/chat
#   Body (JSON) :
{
  "session_id": "{{ $json.user_id }}",
  "message": "{{ $json.text }}"
}

# Nœud 3 : Répondre au Webhook (accusé de réception Slack en < 3s)
#   Réponse : { "response_type": "ephemeral", "text": "En cours de traitement..." }

# Nœud 4 : HTTP Request (poster la réponse finale dans Slack)
#   Méthode : POST
#   URL : {{ $json.response_url }}
#   Body :
{
  "response_type": "in_channel",
  "text": "{{ $('HTTP Request').item.json.reponse }}"
}

# Comportement attendu :
# Utilisateur : /support Quelle est la politique de remboursement ?
# Slack reçoit : "Notre politique de remboursement autorise les retours sous 30 jours..."
# Temps de réponse : ~2-4 secondes (Llama 3.2 7B avec GPU)

Conseil de mise à l'échelle : La mémoire de session ci-dessus est en mémoire vive (perdue au redémarrage). En production, remplacez-la par RedisChatMessageHistory depuis langchain_community.chat_message_histories. Ajoutez un conteneur Redis à votre Docker Compose : plusieurs instances du chatbot partageront alors le même historique de conversation.

Architecture combinée : un exemple concret

Voici une architecture réelle déployée par une PME de 50 personnes pour automatiser le traitement de ses documents clients (factures, contrats, devis) :

# Script Python orchestrant Ollama + ChromaDB
# Déclenché par n8n à chaque nouveau document

import ollama
import chromadb
from pathlib import Path
from datetime import datetime
import json

# Client ChromaDB persistant
chroma_client = chromadb.PersistentClient(path="/data/company_docs")
collection = chroma_client.get_or_create_collection(
    name="documents",
    metadata={"hnsw:space": "cosine"}
)

def extract_and_store_document(file_path: str, doc_id: str) -> dict:
    """
    Extrait les infos clés d'un document et les stocke pour recherche future.
    Compatible avec les formats texte. Pour PDF, utilisez PyPDF2 au préalable.
    """
    text = Path(file_path).read_text(encoding="utf-8")

    # Extraction structurée via Ollama
    extraction_prompt = f"""Extrais de ce document :
1. Type (FACTURE/CONTRAT/DEVIS/AUTRE)
2. Montant total en EUR (0 si absent)
3. Date du document (format YYYY-MM-DD)
4. Nom du client ou fournisseur
5. Résumé en 1 phrase

Réponds en JSON valide uniquement.

Document :
{text[:3000]}"""

    response = ollama.chat(
        model='llama3.2',
        messages=[{
            'role': 'user',
            'content': extraction_prompt
        }],
        format='json'  # Force la sortie JSON
    )

    metadata = json.loads(response['message']['content'])
    metadata['processed_at'] = datetime.now().isoformat()
    metadata['file_path'] = file_path

    # Embeddings via Ollama (modèle léger, ~100ms)
    embedding_response = ollama.embeddings(
        model='nomic-embed-text',
        prompt=text[:2000]
    )

    # Stockage dans ChromaDB
    collection.add(
        documents=[text[:5000]],
        embeddings=[embedding_response['embedding']],
        metadatas=[metadata],
        ids=[doc_id]
    )

    return metadata

# Exemple d'utilisation
result = extract_and_store_document(
    file_path="/data/uploads/facture_2026_04_001.txt",
    doc_id="FAC-2026-04-001"
)
print(json.dumps(result, indent=2, ensure_ascii=False))
# {
#   "type": "FACTURE",
#   "montant": 4250.00,
#   "date": "2026-04-03",
#   "client": "Dupont & Associes",
#   "résumé": "Facture pour prestation de conseil en transformation digitale",
#   "processed_at": "2026-04-06T09:14:32.451Z"
# }

Architecture de production : Ajoutez une file d'attente (Redis Queue ou AWS SQS) entre n8n et votre script Python pour traiter les documents en parallèle sans surcharger Ollama. n8n gère l'ingestion, la file gère le lissage de charge.

Comparatif coûts : open source vs APIs propriétaires

Prenons un cas concret : une équipe qui traite 10 000 documents par mois, chaque document nécessitant ~2 000 tokens en entrée et ~500 tokens en sortie.

Solution	Coût mensuel	Coût annuel	Données quittent l'infra
OpenAI GPT-4o	EUR 275	EUR 3 300	Oui
Anthropic Claude Sonnet	EUR 230	EUR 2 760	Oui
Ollama (EC2 g4dn.xlarge)	EUR 135	EUR 1 620	Non
Ollama (serveur dédié)	EUR 40-80	EUR 480-960	Non

L'économie est significative, mais le vrai avantage est la confidentialité. Pour les cabinets d'avocats, les cliniques, les banques ou toute entreprise traitant des données sensibles, l'absence d'envoi vers un tiers n'est pas un avantage optionnel — c'est une exigence légale.

Se former et passer à l'action

Maîtriser ces trois outils ensemble représente environ 20-30 heures de pratique pour un profil technique. La courbe d'apprentissage la plus raide est LangChain — les abstractions LCEL (LangChain Expression Language) demandent un temps d'adaptation.

Notre formation Agents IA couvre LangChain et LangGraph en profondeur, avec des exercices pratiques sur Ollama. Pour les équipes qui veulent adopter n8n sans passer par le code, la formation Automatisation IA No-Code est le point d'entrée idéal. Financement OPCO disponible pour les deux.

Pour une introduction pratique à LangChain et LangGraph, notre article dédié couvre les patterns LCEL, le RAG avancé et la construction d'agents multi-étapes avec des exemples de code complets.

Questions fréquentes

Ollama est-il utilisable en production pour une entreprise ?

Oui, a condition de dimensionner correctement l'infrastructure. Ollama fonctionne parfaitement en production sur des serveurs avec GPU (NVIDIA A10 ou superieur pour des modeles 7B-13B). La plupart des entreprises deploient Ollama sur AWS EC2 (instances g4dn ou g5), GCP ou Azure. Pour des volumes faibles a moyens (< 1000 req/jour), un serveur dedié suffit. Au-dela, combinez Ollama avec un load balancer et plusieurs instances.

LangChain est-il encore pertinent en 2026 face a LlamaIndex et Haystack ?