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

Le paysage de l'IA open source en 2026

Il y a deux ans, "IA en entreprise" signifiait presque systématiquement payer OpenAI ou Google pour accéder à leurs API, en transmettant vos données au passage, et en acceptant des factures imprévisibles qui augmentaient avec chaque nouveau cas d'usage. Ce modèle se fissure.

En 2026, une stack open source mature — Ollama, LangChain, n8n et CrewAI — couvre le pipeline complet, de l'inférence à l'orchestration multi-agents. Ces outils ne sont pas des prototypes de recherche : ce sont des déploiements en production dans des milliers d'entreprises, dont beaucoup ont publiquement partagé leurs économies de coûts et leurs choix d'architecture.

Cet article vous donne les données pratiques pour prendre la bonne décision pour votre organisation : benchmarks GPU, modèles TCO pour trois profils d'usage courants, code fonctionnel pour chaque outil, et une matrice de décision qui associe les outils aux cas d'usage.

Pour qui est cet article : CTOs et responsables engineering évaluant l'adoption de l'IA open source, développeurs construisant leur premier pipeline IA en production, architectes techniques concevant l'infrastructure IA d'une entreprise. Vous devez être à l'aise avec la lecture de code Python et avoir une compréhension de base des API REST.

Vue d'ensemble : la stack quatre outils

Outil	Rôle	Langage	Stars GitHub	Idéal pour
Ollama	Inférence LLM locale	Go	95k+	Modèles on-premise, souveraineté des données
LangChain	Framework pipelines IA	Python / JS	90k+	RAG, agents, chaînes multi-étapes complexes
n8n	Automatisation workflows	TypeScript	46k+	Intégrations métier, déclencheurs IA no-code
CrewAI	Orchestration multi-agents	Python	28k+	Tâches complexes nécessitant des agents spécialisés

Ces outils ne sont pas concurrents — ils occupent des couches différentes de la stack. L'architecture typique : Ollama fournit l'inférence de modèles locale, LangChain implémente la logique IA, n8n gère l'orchestration des workflows métier, et CrewAI coordonne les tâches multi-agents quand un seul appel LLM ne suffit pas. Ils se composent naturellement.

Ollama : inférence LLM locale avec benchmarks réels

Ollama est un runtime léger qui télécharge et sert des LLMs open source via une API REST compatible OpenAI. Une commande pour installer, une pour télécharger un modèle, une pour démarrer à servir. L'avantage clé : vos données ne quittent jamais votre infrastructure.

Installation et configuration

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

# Télécharger les modèles (stockés localement dans ~/.ollama/models)
ollama pull llama3.2              # 3B — rapide, ~2 Go disque
ollama pull llama3.3:70b          # 70B — meilleure qualité, ~40 Go disque
ollama pull nomic-embed-text      # Embeddings pour RAG
ollama pull mistral-nemo          # 12B — bon équilibre vitesse/qualité

# Démarrer le service (en arrière-plan, port 11434)
ollama serve

# Tester
curl http://localhost:11434/api/generate -d '{
  "model": "llama3.2",
  "prompt": "Résume en une phrase : L\'intelligence artificielle transforme les entreprises.",
  "stream": false
}'

Résultats de benchmarks GPU (tests 2026)

Tokens par seconde mesurés sur des tâches métier représentatives (résumé de documents, Q&R sur un contexte de 2 000 tokens). Tous les tests avec Ollama 0.5.x, quantification Q4_K_M sauf indication contraire.

Matériel	Modèle	Tokens/sec	Premier token (ms)	Coût/mois (AWS)
g4dn.xlarge (T4 16 Go)	Llama 3.2 7B	58 tok/s	180 ms	EUR 135 (on-demand)
g4dn.xlarge (T4 16 Go)	Mistral Nemo 12B	34 tok/s	290 ms	EUR 135 (on-demand)
g5.2xlarge (A10G 24 Go)	Llama 3.3 70B	22 tok/s	520 ms	EUR 380 (on-demand)
CPU seul (c5.4xlarge)	Phi-3 Mini 3.8B	8 tok/s	850 ms	EUR 95 (on-demand)
MacBook Pro M3 Max (local)	Llama 3.3 70B	35 tok/s	220 ms	Matériel amorti

Note sur les benchmarks : Ces chiffres mesurent les tokens/seconde en phase de génération. La latence au premier token (TTFT) est plus importante pour les cas d'usage interactifs comme les chatbots. Pour le traitement par lots (analyse de documents, pipelines nocturnes), le débit de génération est la métrique à optimiser.

Utilisation de l'API compatible OpenAI

La fonctionnalité la plus sous-utilisée d'Ollama : il imite exactement l'API REST OpenAI. Changez une variable d'environnement et les intégrations OpenAI existantes fonctionnent sans modification.

# Remplacement drop-in pour OpenAI — ne changer que l'URL de base et le nom du modèle
from openai import OpenAI

# Pointer le SDK vers votre instance Ollama locale
client = OpenAI(
    base_url="http://localhost:11434/v1",  # CHANGÉ : pointe vers Ollama local
    api_key="ollama",                       # CHANGÉ : toute chaîne fonctionne
)

# Appel de style OpenAI — aucun autre changement nécessaire
response = client.chat.completions.create(
    model="llama3.3:70b",   # Était : "gpt-4o"
    messages=[
        {"role": "system", "content": "Vous êtes un analyste métier senior."},
        {"role": "user", "content": "Identifiez les risques clés dans cet extrait de contrat : [...]"}
    ],
    temperature=0.1,
    max_tokens=500,
)
print(response.choices[0].message.content)

# Le streaming fonctionne de façon identique
stream = client.chat.completions.create(
    model="llama3.2",
    messages=[{"role": "user", "content": "Rédigez un email de suivi professionnel"}],
    stream=True,
)
for chunk in stream:
    print(chunk.choices[0].delta.content or "", end="", flush=True)

LangChain : orchestrer vos pipelines IA

LangChain est le framework Python le plus adopté pour la construction d'applications IA — plus de 50 millions de téléchargements mensuels au T1 2026. Il fournit des abstractions composables pour connecter les LLMs à vos données, outils et logique métier. LangGraph, son extension de workflow avec état, gère les flux d'agents multi-étapes avec une gestion d'état explicite.

Pipeline RAG avec LangChain + Ollama

Le pattern entreprise le plus courant : un chatbot qui répond à des questions à partir de documents internes. Cet exemple traite des PDFs et expose un endpoint API REST.

# pip install langchain langchain-ollama langchain-community chromadb pypdf fastapi uvicorn
from langchain_ollama import OllamaLLM, OllamaEmbeddings
from langchain_community.vectorstores import Chroma
from langchain_community.document_loaders import PyPDFDirectoryLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.chains import RetrievalQA
from langchain.prompts import PromptTemplate
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

# --- Construire la base de connaissances (une seule fois, puis réutiliser ChromaDB) ---
def build_knowledge_base(dossier_docs: str, persist_dir: str) -> Chroma:
    loader = PyPDFDirectoryLoader(dossier_docs)
    docs_bruts = loader.load()

    splitter = RecursiveCharacterTextSplitter(
        chunk_size=800,
        chunk_overlap=120,
        separators=["

", "
", ".", " "],
    )
    chunks = splitter.split_documents(docs_bruts)
    print(f"Chargé {len(docs_bruts)} pages, découpé en {len(chunks)} chunks")

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

# Charger (ou reconstruire) la base de connaissances
vectorstore = Chroma(
    persist_directory="./base_connaissances",
    embedding_function=OllamaEmbeddings(model="nomic-embed-text"),
)

# Prompt personnalisé — ancre le modèle au contexte récupéré
QA_PROMPT = PromptTemplate(
    template="""Vous êtes un assistant utile pour notre entreprise. Utilisez uniquement le contexte ci-dessous pour répondre.
Si la réponse n'est pas dans le contexte, dites "Je n'ai pas cette information dans la documentation."

Contexte :
{context}

Question : {question}

Réponse :""",
    input_variables=["context", "question"],
)

llm = OllamaLLM(model="llama3.2", temperature=0.05)
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever(search_kwargs={"k": 4}),
    chain_type_kwargs={"prompt": QA_PROMPT},
    return_source_documents=True,
)

class QueryRequest(BaseModel):
    question: str

@app.post("/ask")
def ask(req: QueryRequest):
    result = qa_chain.invoke({"query": req.question})
    sources = list({doc.metadata.get("source", "inconnu") for doc in result["source_documents"]})
    return {"answer": result["result"], "sources": sources}

# Démarrage : uvicorn rag_api:app --reload --host 0.0.0.0 --port 8000

Conseil production : Ajoutez la récupération MMR (Maximal Marginal Relevance) pour réduire le contexte dupliqué :retriever=vectorstore.as_retriever(search_type="mmr", search_kwargs={"k": 4, "fetch_k": 20}). Cela améliore la qualité des réponses de 15-25% sur les documents avec du contenu répété (manuels RH, contrats juridiques, spécifications techniques).

LangGraph : agent avec état et utilisation d'outils

# pip install langgraph langchain-ollama langchain-community
from typing import TypedDict, Annotated
from langgraph.graph import StateGraph, END
from langgraph.prebuilt import ToolNode
from langchain_ollama import ChatOllama
from langchain_core.messages import HumanMessage
from langchain.tools import tool
import operator

# --- Définir l'état de l'agent ---
class AgentState(TypedDict):
    messages: Annotated[list, operator.add]

# --- Définir les outils métier ---
@tool
def rechercher_base_connaissances(requete: str) -> str:
    """Rechercher dans la base de connaissances interne les politiques ou informations produit."""
    # En production : appeler votre vectorstore ChromaDB ici
    return f"Résultat pour '{requete}': [Le contexte récupéré apparaîtrait ici]"

@tool
def creer_ticket_support(sujet: str, priorite: str, description: str) -> str:
    """Créer un ticket de support dans le CRM."""
    # En production : appeler votre API CRM (HubSpot, Salesforce, Zendesk)
    ticket_id = f"TICK-{hash(sujet) % 10000:04d}"
    return f"Ticket {ticket_id} créé avec priorité {priorite}"

tools = [rechercher_base_connaissances, creer_ticket_support]
tool_node = ToolNode(tools)

llm = ChatOllama(model="llama3.3:70b", temperature=0.1)
llm_with_tools = llm.bind_tools(tools)

def call_model(state: AgentState) -> AgentState:
    response = llm_with_tools.invoke(state["messages"])
    return {"messages": [response]}

def should_continue(state: AgentState) -> str:
    last_message = state["messages"][-1]
    if hasattr(last_message, "tool_calls") and last_message.tool_calls:
        return "tools"
    return END

workflow = StateGraph(AgentState)
workflow.add_node("agent", call_model)
workflow.add_node("tools", tool_node)
workflow.set_entry_point("agent")
workflow.add_conditional_edges("agent", should_continue)
workflow.add_edge("tools", "agent")

agent = workflow.compile()

result = agent.invoke({
    "messages": [HumanMessage(content="Je ne trouve pas la politique de retour. Pouvez-vous aider et créer un ticket si nécessaire ?")]
})
print(result["messages"][-1].content)
# → "J'ai consulté la base de connaissances et trouvé notre politique de retour : [...]
#    J'ai également créé le ticket TICK-0847 pour votre demande."

n8n : automatisation no-code pour workflows IA

n8n est la plateforme d'automatisation de workflows open source comparable à Zapier ou Make — mais auto-hébergeable, avec des nodes d'intégration IA natives, et gratuite au niveau Community Edition. Elle connecte votre logique IA (scripts LangChain, APIs Ollama) à vos outils métier (CRM, ERP, email, Slack, bases de données) sans exiger que les ingénieurs écrivent du code d'intégration pour chaque connexion.

Configuration self-hosted avec Docker Compose

# docker-compose.yml — n8n avec persistance PostgreSQL
version: "3.8"
services:
  postgres:
    image: postgres:16
    environment:
      POSTGRES_USER: n8n
      POSTGRES_PASSWORD: ${N8N_DB_PASSWORD}
      POSTGRES_DB: n8n
    volumes:
      - postgres_data:/var/lib/postgresql/data

  n8n:
    image: n8nio/n8n:latest
    ports:
      - "5678:5678"
    environment:
      DB_TYPE: postgresdb
      DB_POSTGRESDB_HOST: postgres
      DB_POSTGRESDB_USER: n8n
      DB_POSTGRESDB_PASSWORD: ${N8N_DB_PASSWORD}
      DB_POSTGRESDB_DATABASE: n8n
      N8N_BASIC_AUTH_ACTIVE: "true"
      N8N_BASIC_AUTH_USER: admin
      N8N_BASIC_AUTH_PASSWORD: ${N8N_ADMIN_PASSWORD}
      WEBHOOK_URL: https://n8n.votredomaine.com
      N8N_ENCRYPTION_KEY: ${N8N_ENCRYPTION_KEY}
    volumes:
      - n8n_data:/home/node/.n8n
    depends_on:
      - postgres

volumes:
  postgres_data:
  n8n_data:

# Déploiement : docker compose up -d
# Accès : https://n8n.votredomaine.com (après configuration du reverse proxy)

Workflow réel : traitement de factures avec extraction IA

# Configuration du workflow n8n (export JSON — importer via l'UI)
# Nœuds en séquence :
# 1. Email Trigger (IMAP) → surveille factures@entreprise.com
# 2. Filtre → garde uniquement les emails avec pièces jointes PDF
# 3. HTTP Request → extrait le texte PDF via un endpoint Python simple
# 4. HTTP Request → appelle Ollama pour l'extraction structurée
# 5. Code node → parse la réponse JSON, valide les champs requis
# 6. Google Sheets → ajoute une ligne à la feuille de suivi des factures
# 7. Slack → notifie l'équipe finance si montant > EUR 5 000

# Nœud 4 : Extraction IA Ollama (config du nœud HTTP Request)
# URL : http://ollama-service:11434/api/generate
# Méthode : POST
# Corps (JSON) :
{
  "model": "llama3.3:70b",
  "prompt": "Extrayez de ce texte de facture. Retournez UNIQUEMENT du JSON valide, sans explication :\n\n{{ $json.pdf_text }}\n\nFormat attendu: {\"fournisseur\": string, \"montant_eur\": number, \"date_facture\": \"YYYY-MM-DD\", \"numero_facture\": string, \"date_echeance\": \"YYYY-MM-DD\"}",
  "stream": false,
  "format": "json"
}

# Nœud 5 : Code node (JavaScript) — validation et enrichissement
const raw = JSON.parse($json.response);

if (!raw.fournisseur || !raw.montant_eur || !raw.date_facture) {
  throw new Error(`Extraction incomplète : ${JSON.stringify(raw)}`);
}

const echeance = new Date(raw.date_echeance);
const today = new Date();
const joursAvantEcheance = Math.ceil((echeance - today) / (1000 * 60 * 60 * 24));

return {
  ...raw,
  jours_avant_echeance: joursAvantEcheance,
  en_retard: joursAvantEcheance < 0,
  traite_le: new Date().toISOString(),
};

Tarifs n8n : self-hosted vs Cloud

Offre	Coût mensuel	Exécutions	Idéal pour
Community (self-hosted)	EUR 0 + VPS EUR 10–20	Illimitées	Équipes techniques, données RGPD-sensibles
Starter (Cloud)	EUR 20	2 500/mois	Petites équipes, démarrage rapide, sans DevOps
Pro (Cloud)	EUR 50	10 000/mois	Équipes en croissance, multiples workflows actifs
Enterprise	Sur devis	Illimitées	SSO, logs d'audit, SLA, support dédié

CrewAI : orchestration multi-agents

CrewAI structure le travail IA comme un équipage d'agents spécialisés, chacun avec un rôle, un objectif et un ensemble d'outils. Contrairement à un seul appel LLM, un équipage peut paralléliser la recherche, avoir un agent qui valide le travail d'un autre, et produire des outputs qui émergent de la collaboration entre agents. Le cas d'usage optimal : les tâches complexes où aucun prompt unique ne produit de façon fiable de bons résultats.

Exemple fonctionnel : crew recherche et rédaction de contenu

# pip install crewai crewai-tools langchain-ollama
from crewai import Agent, Task, Crew, Process
from crewai_tools import SerperDevTool  # Recherche web (tier gratuit disponible)
from langchain_ollama import ChatOllama

# Utiliser un modèle Ollama local pour tous les agents (coût API zéro)
llm_local = ChatOllama(model="llama3.3:70b", temperature=0.2)

# --- Définir les agents spécialisés ---
chercheur = Agent(
    role="Analyste Recherche Senior",
    goal="Trouver des informations précises et à jour sur le sujet donné depuis des sources fiables",
    backstory=(
        "Vous avez 10 ans d'expérience en études de marché. Vous êtes reconnu pour "
        "trouver des faits que les autres ratent et pour citer vos sources méticuleusement."
    ),
    llm=llm_local,
    tools=[SerperDevTool()],
    verbose=True,
    max_iter=4,
)

redacteur = Agent(
    role="Rédacteur Technique Senior",
    goal="Rédiger du contenu technique clair, engageant et précis basé sur la recherche",
    backstory=(
        "Vous êtes spécialisé dans la traduction de sujets techniques complexes en contenu "
        "accessible pour un public professionnel. Vous structurez le contenu logiquement."
    ),
    llm=llm_local,
    verbose=True,
)

editeur = Agent(
    role="Éditeur de Contenu",
    goal="Relire et améliorer le brouillon pour la clarté, la précision et le ton professionnel",
    backstory=(
        "Vous êtes un éditeur méticuleux qui repère les incohérences, améliore la clarté "
        "et s'assure que le contenu est factuellement fondé et sans jargon marketing."
    ),
    llm=llm_local,
    verbose=True,
)

# --- Définir les tâches ---
tache_recherche = Task(
    description=(
        "Recherchez l'état actuel du déploiement de LLMs open source en entreprise. "
        "Focus sur : (1) modèles en production, (2) patterns d'infrastructure, "
        "(3) économies de coûts documentées avec des chiffres réels. "
        "Sujet : {sujet}"
    ),
    expected_output="Un brief de recherche structuré : résultats clés, 5+ sources citées, chiffres spécifiques.",
    agent=chercheur,
)

tache_redaction = Task(
    description=(
        "En utilisant le brief de recherche, rédigez une section blog technique de 600 mots. "
        "Commencez par la découverte la plus surprenante. Utilisez des titres, des listes "
        "à puces et au moins un tableau de données. Pas de langage marketing."
    ),
    expected_output="Une section blog de 600 mots en Markdown, soignée.",
    agent=redacteur,
    context=[tache_recherche],
)

tache_edition = Task(
    description=(
        "Relisez la section blog rédigée. Corrigez les lacunes factuelles, améliorez "
        "la phrase d'accroche et assurez-vous que toutes les statistiques sont bien attribuées."
    ),
    expected_output="Section blog éditée finale en Markdown, prête à publier.",
    agent=editeur,
    context=[tache_redaction],
)

# --- Assembler et lancer l'équipage ---
crew = Crew(
    agents=[chercheur, redacteur, editeur],
    tasks=[tache_recherche, tache_redaction, tache_edition],
    process=Process.sequential,
    verbose=True,
)

result = crew.kickoff(inputs={"sujet": "Déploiement de LLM open source en entreprise en 2026"})
print(result.raw)
# Durée estimée : 3-8 minutes avec llama3.3:70b (Ollama local)
# Utilisation tokens : ~15 000-25 000 tokens au total pour tous les agents

Contrôle des coûts : Définissez max_iter=3 sur tous les agents et max_rpm=10 sur le Crew pour éviter les boucles incontrôlées. En production, ajoutez des hooks de callback pour logger chaque étape agent et alerter sur les workflows dépassant 30 itérations. Un crew de 3 agents sur une tâche complexe utilise typiquement 3-5× plus de tokens qu'un prompt unique bien conçu — budgétisez en conséquence.

CrewAI vs LangGraph : quand utiliser lequel

Dimension	CrewAI	LangGraph
Courbe d'apprentissage	Faible — abstraction role-based	Moyenne — graphes d'état explicites
Temps pour une première démo	2-4 heures	4-8 heures
Contrôle en production	Limité (boucles agents opaques)	Total (transitions explicites)
Observabilité	Dashboard CrewAI+ (payant)	LangSmith (tier gratuit disponible)
Checkpointing / reprise	Limité	Natif — survit aux redémarrages
Meilleur cas d'usage	Recherche, contenu, analyse	Agents client-facing, workflows complexes

Matrice de décision : quel outil pour quel besoin

Besoin métier	Outil principal	Outil de support	Délai de mise en place typique
Faire tourner l'IA sans envoyer les données dans le cloud	Ollama	—	1-2 heures
Chatbot Q&R sur documents internes	LangChain	Ollama (inférence)	1-2 jours
Automatiser un processus métier avec décisions IA	n8n	Ollama (appels IA)	0,5-1 jour
Recherche ou génération de contenu à grande échelle	CrewAI	Ollama (local) ou API Claude	1-2 jours
Agent IA client-facing (grade production)	LangGraph	Ollama + n8n	3-5 jours
Pipeline IA entreprise complet	Les quatre	Ollama + LangChain + n8n + CrewAI	2-4 semaines

Analyse TCO : trois scénarios réels

Calculs de Coût Total de Possession (TCO) pour trois profils d'entreprise représentatifs. Les coûts d'infrastructure utilisent les tarifs AWS on-demand (eu-west-1, avril 2026). Les coûts de licences sont nuls pour tous les outils (Apache 2.0). Les coûts d'API utilisent les tarifs publics actuels.

Scénario 1 : PME avec 5 000 requêtes IA/mois

Profil : entreprise de 20 personnes, chatbot service client IA, FAQ RH interne, traitement automatisé des factures.

Approche	Infrastructure	Coût IA/mois	Total/mois	TCO annuel
API OpenAI GPT-4o	EUR 0 (serverless)	EUR 687	EUR 687	EUR 8 244
API Claude Sonnet	EUR 0 (serverless)	EUR 457	EUR 457	EUR 5 484
Ollama (g4dn.xlarge)	EUR 135/mois	EUR 0	EUR 135	EUR 1 620
Ollama (VPS dédié)	EUR 80/mois	EUR 0	EUR 80	EUR 960

Économies : Passer de GPT-4o à Ollama sur un VPS GPU dédié économise EUR 7 284/an (réduction de 88%) pour ce profil. Le serveur nécessite 4-8 heures de configuration initiale.

Scénario 2 : Scale-up avec 50 000 requêtes IA/mois

Approche	Infrastructure	Coût IA/mois	Total/mois	TCO annuel
API OpenAI GPT-4o	EUR 0	EUR 6 875	EUR 6 875	EUR 82 500
API Claude Sonnet	EUR 0	EUR 4 583	EUR 4 583	EUR 55 000
Ollama (2× g4dn.xlarge)	EUR 270/mois	EUR 0	EUR 270	EUR 3 240
Hybride (Ollama + Claude Sonnet pour le complexe)	EUR 270/mois	EUR 916	EUR 1 186	EUR 14 232

Scénario 3 : Grande entreprise avec workflows multi-agents (200 000+ requêtes/mois)

Approche	Infrastructure	Coût IA/mois	Total/mois	TCO annuel
Entièrement propriétaire (GPT-4o)	EUR 0	EUR 27 500	EUR 27 500	EUR 330 000
Entièrement open source (cluster Ollama)	EUR 1 200/mois	EUR 0	EUR 1 200	EUR 14 400
Hybride (Ollama 85% + Claude 15%)	EUR 1 200/mois	EUR 4 125	EUR 5 325	EUR 63 900

Mise en garde infrastructure : Le scénario "entièrement open source" nécessite une équipe infrastructure ML dédiée (au moins un ingénieur senior DevOps/MLOps) pour gérer les clusters GPU, les mises à jour de modèles, le monitoring et le failover. Intégrez EUR 60 000-100 000/an de temps ingénierie avant de le déclarer moins cher à grande échelle.

Guide de migration : du propriétaire vers l'open source

Étape 1 : Auditer votre utilisation actuelle de l'API

# Lancer ceci contre votre codebase pour cartographier tous les points d'appel LLM
grep -r "openai|anthropic|gpt-4|claude" ./src --include="*.py" -l

# Pour chaque fichier trouvé, vérifier :
# 1. Quel modèle est appelé (influence le choix du modèle Ollama)
# 2. Nombre de tokens moyen (influence le dimensionnement du matériel)
# 3. Si le streaming est utilisé
# 4. Si le function calling / tools est utilisé (CrewAI/LangGraph requis)
# 5. Si des fonctionnalités vision ou audio sont utilisées (support multimodal Ollama limité)

Étape 2 : Remplacer le client (zéro changement de logique métier)

# Avant (OpenAI)
from openai import OpenAI
client = OpenAI(api_key="sk-...")
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Résume ce document : ..."}],
)

# Après (Ollama) — seulement 2 lignes changent
from openai import OpenAI
client = OpenAI(
    base_url="http://localhost:11434/v1",  # CHANGÉ
    api_key="ollama",                       # CHANGÉ (n'importe quelle valeur)
)
response = client.chat.completions.create(
    model="llama3.3:70b",   # CHANGÉ : nom du modèle Ollama
    messages=[{"role": "user", "content": "Résume ce document : ..."}],
)

# LangChain : encore plus simple — changer uniquement l'import
# Avant : from langchain_openai import ChatOpenAI
# Après :  from langchain_ollama import ChatOllama
# Puis :   llm = ChatOllama(model="llama3.3:70b") au lieu de ChatOpenAI(model="gpt-4o")

Stratégie de migration : Commencez par les workflows internes à faibles enjeux (FAQ RH, recherche interne, résumé de documents pour le personnel). Conservez les API propriétaires pour les tâches client-facing à forts enjeux (analyse juridique, médical, décisions financières) jusqu'à avoir validé la qualité d'Ollama sur un échantillon représentatif de vos entrées de production réelles. Prévoyez 2-4 semaines de validation à une échelle significative.

Questions fréquentes

Quelle est la vraie difference de TCO entre Ollama et l'API OpenAI a grande echelle ?

Pour 50 000 requetes/mois avec une moyenne de 2 500 tokens : OpenAI GPT-4o coute environ EUR 1 375/mois en frais d'API. Ollama sur une AWS g4dn.2xlarge (1 NVIDIA T4, 16 Go VRAM) coute EUR 380/mois — soit 73% moins cher. A 200 000 requetes/mois, l'ecart se creuse : EUR 5 500 contre EUR 380 (meme serveur). Le seuil de rentabilite ou Ollama devient moins cher se situe entre 8 000 et 12 000 requetes/mois selon la taille du modele.

CrewAI ou LangGraph : lequel choisir pour un systeme multi-agents en production ?

CrewAI est plus rapide a prendre en main (abstraction role-based, peu de code) mais offre moins de controle sur l'etat et le flux. LangGraph donne des machines a etats explicites, un checkpointing natif et une observabilite via LangSmith — indispensable pour debugger en production. Recommandation : prototyper avec CrewAI (1-2 jours pour une demo fonctionnelle), puis evaluer si vous avez besoin du plan de controle de LangGraph. La plupart des equipes qui rencontrent des problemes de fiabilite avec CrewAI migrent vers LangGraph a 3-6 mois.

n8n peut-il remplacer LangChain pour la plupart des workflows IA metier ?

Pour les workflows lineaires simples (declencheur -> appel LLM -> action), oui. Les nodes IA de n8n couvrent 80% des patterns d'automatisation courants sans code. Mais pour les pipelines RAG complexes, les agents multi-etapes ou la logique de retrieval personnalisee, LangChain est necessaire. Le pattern typique : n8n pour l'orchestration des processus metier (declenchement, routage, integrations), scripts Python LangChain pour la logique IA, appeles depuis le node Execute Command de n8n.

Quel materiel GPU faut-il pour faire tourner Llama 3.3 70B en production ?

Llama 3.3 70B en quantification Q4 necessite environ 40 Go de VRAM. Sur AWS : g5.12xlarge (4 A10G, 96 Go VRAM, ~EUR 5,50/h a la demande, ~EUR 1,65/h spot). On-premise : 2 NVIDIA RTX 4090 (48 Go VRAM combines, ~EUR 3 200 de materiel). Pour des charges plus legeres, Llama 3.2 11B (Q4 : 7 Go VRAM) tourne sur une seule RTX 3080 ou g4dn.xlarge et gere la plupart des taches de traitement de documents metier a 40-60 tokens/seconde.

Comment migrer une integration OpenAI existante vers Ollama sans tout réécrire ?

Ollama expose une API REST compatible OpenAI sur /v1/chat/completions. Changez une variable d'environnement : OPENAI_BASE_URL=http://localhost:11434/v1 et OPENAI_API_KEY=ollama (n'importe quelle chaine fonctionne). Le SDK Python OpenAI et la classe ChatOpenAI de LangChain routeront automatiquement les requetes vers Ollama. Le seul changement de code necessaire : remplacer model='gpt-4o' par model='llama3.3:70b'. Aucun autre changement requis.

Pour aller plus loin ? Notre formation Agents IA couvre LangChain, LangGraph et CrewAI dans un workshop pratique de 2 jours avec des exercices fonctionnant sur Ollama. Pour les équipes orientées automatisation, la formation Automatisation IA No-Code couvre n8n en profondeur avec des templates de workflows métier réels.

Outils IA Open Source pour Entreprises 2026 : Ollama, LangChain, n8n et CrewAI Comparés