# pip install langchain langchain-openai
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
# 1) Model
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
# 2) Prompt
prompt = ChatPromptTemplate.from_messages( et un guide de diffusion en continu.
---
## Blocs de construction que vous utiliserez 80 % du temps
### 1) Prompts et parsing de la sortie
- Utilisez `ChatPromptTemplate` pour des prompts structurés.
- Analysez les sorties avec `StrOutputParser` ou des analyseurs JSON pour des réponses typées.
```python
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="gpt-4o-mini")
prompt = ChatPromptTemplate.from_template(
"""
Résumez le texte suivant en 3 points :
---
{text}
"""
)
parser = StrOutputParser
chain = prompt | llm | parser
summary = chain.invoke({"text": "LangChain aide à construire des applications LLM avec RAG et des outils."})
print(summary)

# pip install faiss-cpu tiktoken
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_community.vectorstores import FAISS
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_core.prompts import ChatPromptTemplate
# Prepare documents
texts = .
---
## Du prototype à la production : Un plan étape par étape
### Étape 1 : Définir le scénario utilisateur
- Qui est l'utilisateur ? Quel travail essaie-t-il d'accomplir ?
- Exemple : « Un agent de support qui répond aux questions sur les produits à partir de documents internes et de tickets récents. »
### Étape 2 : Choisir la pile viable minimale
- Modèle : Choisissez un modèle fiable et à prix raisonnable (par exemple, GPT-4o-mini ou un modèle ouvert de pointe).
- Données : Décidez si vous avez besoin de RAG maintenant. Si oui, commencez avec FAISS localement.
- E/S : Utilisez LCEL pour une itération rapide ; évitez le code de colle personnalisé.
### Étape 3 : Mettre en œuvre une boucle RAG propre
- Divisez correctement les documents.
- Indexez les embeddings.
- Proposez avec le contexte et les citations.
- Ajoutez un garde-fou pour éviter les hallucinations lorsqu'aucun contexte pertinent n'est trouvé.
```python
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
qa_prompt = ChatPromptTemplate.from_template(
"""
Répondez à la question en utilisant UNIQUEMENT le CONTEXTE ci-dessous. Si la réponse n'est pas
dans le contexte, dites « Je ne sais pas ». Incluez les identifiants de document cités.
CONTEXTE :
{context}
QUESTION : {question}
"""
)
parser = StrOutputParser
rag_chain = (RunnableParallel(context=retriever, question=RunnableLambda(lambda x: x.
### Étape 5 : Sorties typées et validation
- Utilisez `PydanticOutputParser` ou un schéma JSON pour appliquer la structure des réponses de l'API.
- Validez les champs pour détecter la dérive du modèle.
### Étape 6 : Outils et appel de fonctions pour les tâches réelles
- Introduisez les outils avec parcimonie.
- Outils courants : calculatrice, recherche sur le web, exécuteur de requêtes SQL, exécuteur de code.
- Décrivez clairement les capacités des outils dans les docstrings.
### Étape 7 : Durcissement
- Limitation du débit et stratégies de nouvelle tentative.
- Délais d'attente et disjoncteurs.
- Filtres de sécurité et vérifications du contenu.
### Étape 8 : Évaluation et amélioration continue
- Testez avec des ensembles de données golden (entrée → sortie attendue).
- Évaluez la fidélité, l'exhaustivité des réponses et la précision des citations.
- Mesurez le taux de réussite de la récupération et la latence.
---
## Modèles courants et pièges
- Commencez simplement : Chaînes avant les agents. Vous obtiendrez de la prévisibilité et un coût inférieur.
- Le chunking est important : Le réglage de la taille/du chevauchement des chunks peut modifier la qualité de la récupération plus que le remplacement du modèle.
- Fuite de prompt : Ne mettez pas tout et n'importe quoi dans les prompts système ; gardez-les ciblés.
- Déterminisme : Définissez `temperature=0` pour l'évaluation et les workflows critiques.
- UX de streaming : Diffusez des jetons vers l'interface utilisateur pendant que le reste du système récupère des actifs ou précharge le contexte.
- Sorties structurées : Utilisez des analyseurs pour rendre l'intégration en aval indolore.
---
## Un mini-projet complet : Questions et réponses sur la documentation avec citations
Cet exemple relie tout : ingestion, RAG, génération de réponses et streaming.
```python
# pip install langchain langchain-openai faiss-cpu tiktoken
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import FAISS
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnableParallel, RunnableLambda
# 1) Ingest
corpus = {
"pricing": "Notre plan Pro prend en charge 1M de jetons de contexte et comprend un support prioritaire.",
"limits": "La limite de débit de l'API est de 60 requêtes par minute pour les utilisateurs Pro.",
"security": "Nous stockons les journaux pendant 30 jours, sauf si la journalisation est désactivée par l'administrateur.",
}
splitter = RecursiveCharacterTextSplitter(chunk_size=300, chunk_overlap=50)
all_chunks, ids = [], []
for doc_id, text in corpus.items:
for i, chunk in enumerate(splitter.split_text(text)):
all_chunks.append(chunk)
ids.append(f"{doc_id}-{i}")
# 2) Index
db = FAISS.from_texts(all_chunks, OpenAIEmbeddings)
retriever = db.as_retriever(k=4)
# 3) Prompt
prompt = ChatPromptTemplate.from_template(
"""
Vous êtes un assistant de support. Utilisez le CONTEXTE pour répondre.
En cas de doute, dites « Je ne sais pas ». Incluez les citations des identifiants de source.
CONTEXTE :
{context}
QUESTION : {question}
"""
)
# 4) Model and parser
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
parser = StrOutputParser
# 5) Compose chain
rag = (
RunnableParallel(
context=retriever,
question=RunnableLambda(lambda x: x["question"]) # pass-through
)
| prompt
| llm
| parser
)
# 6) Ask a question
for chunk in rag.stream({"question": "What are Pro rate limits and log retention?"}):
print(chunk, end="", flush=True)