Guide d’installation de FastAPI et
Chatbot avec RAG
Étape 1 : Installation de VS Code et Python
1. Télécharger et installer VS Code : Lien de téléchargement
2. Installer Python (si ce n'est pas encore fait) : Lien de téléchargement
Vérifiez l'installation avec :
python --version
Si vous utilisez Windows, assurez-vous d'ajouter Python au PATH lors de
l'installation.
Étape 2 : Création d’un environnement virtuel
Ouvrez VS Code, puis ouvrez un terminal intégré (Ctrl + ` sous Windows/Linux).
Exécutez les commandes suivantes :
Sous Windows (Terminal VS Code ou cmd) :
python -m venv venv
venv\Scripts\activate
Sous macOS/Linux (Terminal VS Code ou bash) :
python3 -m venv venv
source venv/bin/activate
Vous devriez voir (venv) devant la ligne de commande, indiquant que l'environnement est
activé.
Étape 3 : Installation des dépendances
Dans le terminal VS Code, exécutez :
pip install fastapi uvicorn langchain langchain-community langchain-
huggingface langchain-groq sentence-transformers chromadb pydantic groq
Étape 4 : Organisation des fichiers du projet
Dans VS Code, créez la structure suivante :
/mon_projet
│── /app
│ │── __init__.py
│ │── [Link] # Fichier principal pour FastAPI
│ │── [Link] # Contient l'API FastAPI
│── /app/documents/ # Dossiers pour vos fichiers PDF
│── venv/ # Environnement virtuel
│── [Link] # Liste des dépendances
Générez le fichier [Link] pour enregistrer les dépendances :
pip freeze > [Link]
Étape 5 : Implémentation du serveur FastAPI
Dans app/[Link], ajoutez le code suivant :
from fastapi import FastAPI
from [Link] import router
app = FastAPI(title="API Chatbot Juridique", version="1.0")
app.include_router(router)
if __name__ == "__main__":
import uvicorn
[Link]("[Link]:app", host="[Link]", port=8000, reload=True)
Ajoutez l'API dans app/[Link] (avec votre).
import re
import os
from fastapi import APIRouter, HTTPException
from pydantic import BaseModel
from langchain.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_huggingface import HuggingFaceEmbeddings
from langchain_community.vectorstores import Chroma
from [Link] import RetrievalQA
from langchain_groq import ChatGroq
from [Link] import PromptTemplate
from [Link] import ConversationBufferMemory
from groq import Client
from [Link] import jsonable_encoder
import json
router = APIRouter()
# Modèle de requête pour le chatbot
class QueryRequest(BaseModel):
question: str
# Fonction de nettoyage du texte
def clean_text(text):
text = [Link](r'\s+', ' ', text) # Suppression des espaces et
sauts de ligne excessifs
return [Link]() # Suppression des espaces en début/fin
# Liste des documents juridiques à indexer
documents = [
{"path": "app/documents/[Link]", "title": "Code de Commerce
2010"},
{"path": "app/documents/[Link]", "title": "Code Pénal
2011"},
# Ajouter d'autres documents ici...
]
# Initialisation de la liste des documents traités
all_docs = []
# Chargement et traitement des documents
for doc in documents:
pdf_path = doc["path"]
title = doc["title"]
if not [Link](pdf_path):
print(f"⚠️ Attention : {pdf_path} non trouvé, il sera ignoré.")
continue
loader = PyPDFLoader(pdf_path)
pages = [Link]()
for page_num, page in enumerate(pages):
cleaned_text = clean_text(page.page_content)
all_docs.append({
"text": cleaned_text,
"metadata": {"source": pdf_path, "title": title, "page":
page_num + 1}
})
# Découpage du texte en chunks avec inclusion des métadonnées
text_splitter = RecursiveCharacterTextSplitter(chunk_size=500,
chunk_overlap=50)
docs = [
(chunk, doc["metadata"])
for doc in all_docs
for chunk in text_splitter.split_text(doc["text"])
]
# Création d'objets Documents avec métadonnées
from [Link] import Document
final_docs = [
Document(page_content=chunk, metadata=metadata) for chunk, metadata
in docs
]
# Chargement du modèle d'embeddings
persist_directory = "MyDB1"
embedding_function = HuggingFaceEmbeddings(model_name="sentence-
transformers/multi-qa-MiniLM-L6-cos-v1")
# Création ou chargement de la base Chroma avec métadonnées
vectorstore = Chroma.from_documents(final_docs, embedding_function,
persist_directory=persist_directory)
# Configuration de la clé API Groq
api_key = [Link]("GROQ_API_KEY")
if not api_key:
raise ValueError("La clé API GROQ_API_KEY n'est pas définie.")
client = Client(api_key=api_key)
# Initialisation du modèle Groq
groq_llm = ChatGroq(model_name="llama-3.3-70b-versatile")
# Définition du prompt personnalisé
template = """
Tu es un **assistant juridique spécialisé en droit tunisien**.
Ton rôle est de fournir des informations précises et fiables sur la
réglementation et la législation en Tunisie.
Guidez l'utilisateur en lui fournissant des réponses claires et
concises à ses questions juridiques.
Si des informations manquent pour la précision de la réponse vous
pouvez demander à l'utilisateur de les fournir.
### **Contexte juridique disponible** :
{context}
### **Historique de la conversation** :
{chat_history}
### **Utilisateur** : {question}
### **Assistant juridique** :
"""
prompt_template = PromptTemplate(
input_variables=["history", "context", "question"],
template=template,
)
# Initialisation de la mémoire de conversation
memory = ConversationBufferMemory(memory_key="chat_history",
return_messages=True, input_key="question")
# Création de la chaîne QA avec mémoire et récupération des sources
qa_chain = RetrievalQA.from_chain_type(
llm=groq_llm,
chain_type="stuff",
retriever=vectorstore.as_retriever(search_kwargs={"k": 20}), #
Récupération des 5 documents les plus pertinents
return_source_documents=True,
verbose=True,
chain_type_kwargs={"prompt": prompt_template, "memory": memory,
"verbose": True}
)
@[Link]("/chat")
def chat(request: QueryRequest):
try:
response = qa_chain({"query": [Link]}) # Exécute la
requête
answer = response['result']
# 🔍 Debugging: Afficher les sources
print("🔍 Raw source documents:", response['source_documents'])
# Extraction des sources avec métadonnées
sources = []
for doc in response['source_documents']:
print("📝 Metadata:", [Link]) # Debugging : voir les
métadonnées réelles
[Link]({
"source": [Link]("source", "Inconnu"),
"title": [Link]("title", "Inconnu"),
"page": [Link]("page", "Inconnue")
})
# Debugging: Afficher la structure des sources avant retour
print("Formatted sources:", [Link](sources, indent=2,
ensure_ascii=False))
return jsonable_encoder({"response": answer, "sources":
sources})
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
Étape 6 : Configuration des variables d’environnement
Créez un fichier .env dans le dossier mon_projet/ :
GROQ_API_KEY=VOTRE_CLE_GROQ
Ajoutez dans app/[Link] :
from dotenv import load_dotenv
import os
load_dotenv()
api_key = [Link]("GROQ_API_KEY")
if not api_key:
raise ValueError("La clé API GROQ_API_KEY n'est pas définie.")
Installez la bibliothèque dotenv :
pip install python-dotenv
Étape 7 : Lancer l’API FastAPI
Dans VS Code (terminal), exécutez :
uvicorn [Link]:app --reload
L'API sera accessible à [Link] .
Pour tester l'API avec Swagger UI :
Ouvrez [Link] dans votre navigateur.
Étape 8 : Tester avec curl ou Postman
Vous pouvez tester avec Postman ou cURL :
curl -X 'POST' \
'[Link] \
-H 'Content-Type: application/json' \
-d '{"question": "Quels sont les articles du Code du Commerce sur les
contrats ?"}'
Tester l'API avec Swagger UI
1. Lancez votre API dans le terminal VS Code avec la commande :
uvicorn [Link]:app --reload
2. Ouvrez votre navigateur et accédez à :
[Link]
3. Vous verrez l'interface Swagger avec toutes les routes de votre API.
4. Cliquez sur POST /chat, puis sur "Try it out".
5. Dans le champ Request Body, entrez une question comme ceci :
{
"question": "Quels sont les articles du Code du Commerce sur les
contrats ?"
}
6. Cliquez sur "Execute" et observez la réponse de l'API !