Pourquoi RAG est l'avenir de la recherche basée sur l'IA

Les modèles linguistiques sont intelligents, mais ils ne savent pas toujours tout, en particulier lorsque des connaissances en temps réel ou spécifiques à un domaine sont nécessaires.

Entrez dans la génération augmentée par extraction (RAG) : un puissant paradigme qui combine de grands modèles linguistiques (LLM) avec des systèmes de recherche d'informations pour fournir des réponses plus intelligentes, plus pertinentes et plus fondées.

‍

Création d'une génération complète avec récupération augmentée

Dans ce didacticiel, basé sur notre analyse approfondie Tutoriel Youtube, nous allons créer un backend RAG complet en utilisant API rapide, Eden AI, et certains des outils d'IA les plus puissants du marché (comme OpenAI, Qdrant, etc.).

Vous pouvez regarder notre didacticiel détaillé pour voir le détail complet et suivre les instructions étape par étape, au cours desquelles nous vous guiderons à chaque étape du processus, de la configuration de l'environnement au déploiement d'une solution backend robuste, en veillant à ce que vous compreniez chaque concept et son application.

Que vous soyez un développeur souhaitant ajouter des questions et réponses intelligentes à votre application, ou un passionné de ML curieux de savoir comment fonctionne RAG sous le capot, vous êtes au bon endroit.

‍

Ce que nous allons construire

Nous allons créer un système RAG backend complet qui vous permettra de :

• Créez des projets RAG à l'aide de l'API d'Eden AI.
• Téléchargez des données (fichiers, URL ou texte brut).
• Générez des intégrations et stockez-les dans une base de données vectorielles.
• Posez des questions contextuelles à l'aide des LLM.
• Créez et gérez des conversations pour les interfaces basées sur le chat.

‍

Pile technologique

• API rapide — Pour créer notre API principale.
• Eden AI — Résume plusieurs fournisseurs d'IA et donne accès à l'OCR, à la STT, aux intégrations, aux LLM et aux bases de données vectorielles.
• Qdrant — Boutique vectorielle utilisée pour conserver les intégrations de vos documents.
• IA ouverte — Utilisé comme fournisseur pour les intégrations et les LLM.
• Intergiciel CORS — Pour permettre aux applications frontales de se connecter à notre API.

‍

Guide étape par étape :

‍

Partie 1 : Configuration du projet

‍

Commençons par la configuration de base :

from fastapi import FastAPI, HTTPException, UploadFile, File, Form, Query
from fastapi.middleware.cors import CORSMiddleware
import requests
import os

‍

Nous importons les classes et outils FastAPI essentiels pour créer des API, ainsi que des demandes pour envoyer des requêtes HTTP à Eden AI et des systèmes d'accès aux variables d'environnement.

Nous proposons également des modèles Pydantic et quelques utilitaires de saisie :

from typing import List, Optional, Dict, Any
from pydantic import BaseModel, HttpUrl

‍

Ils permettent de définir des modèles de demande/réponse clairs et structurés.

‍

Charger la clé Eden AI

Nous chargeons la clé API à partir de variables d'environnement :

EDEN_AI_API_KEY = os.getenv("EDEN_AI_API_KEY", "your_default_key_here")
if not EDEN_AI_API_KEY:
    raise ValueError("Environment variable EDEN_AI_API_KEY is not set")

‍

Cela garantit que la clé est gérée de manière sécurisée et qu'elle n'est pas codée en dur. Remplacez your_default_key_here par une solution de secours sécurisée ou gérez-la en toute sécurité via .env en production.

‍

Définir l'URL de base et la fonction d'assistance de l'API Eden

Nous définissons maintenant l'URL de base pour le point de terminaison Eden AI RAG et un assistant pour joindre des en-têtes d'autorisation à toutes les demandes sortantes :

BASE_URL = "https://api.edenai.run/v2/agent/rag"

def get_headers():
    return {
        "Authorization": f"Bearer {EDEN_AI_API_KEY}",
        "Content-Type": "application/json"
    }

‍

Partie 2 : Initialisation de FastAPI

‍

Cela initialise notre application FastAPI avec un titre et une description. Utile pour les documents générés automatiquement dans /docs.

‍

Ajoutez le middleware CORS pour autoriser l'accès frontal :

app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

‍

Ceci est crucial pour le développement et l'intégration avec des applications frontales telles que React ou Vue.

‍

Partie 3 : Modèles pour la création de projets RAG

‍

Nous définissons ici les modèles Pydantic qui structurent nos demandes entrantes.

class CreateProjectRequest(BaseModel):
    ocr_provider: str = "amazon"
    speech_to_text_provider: str = "openai"
    llm_provider: Optional[str] = None
    llm_model: Optional[str] = None
    project_name: str
    collection_name: str
    db_provider: str = "qdrant"
    embeddings_provider: str = "openai"
    chunk_size: Optional[int] = None
    chunk_separators: Optional[List[str]] = None

‍

Ces paramètres permettent de personnaliser en profondeur la façon dont les données sont découpées, intégrées et stockées.

‍

Partie 4 : Création et gestion de projets RAG

‍

Création d'un projet

@app.post("/projects")
async def create_project(project_request: CreateProjectRequest):
    payload = project_request.dict(exclude_none=True)
    response = requests.post(
        f"{BASE_URL}/",
        headers=get_headers(),
        json=payload,
    )
    response.raise_for_status()
    return response.json()

‍

Ce point de terminaison crée un nouveau projet RAG dans Eden AI. Il sérialise votre saisie de formulaire au format JSON et l'envoie.

‍

Répertorier et gérer des projets

Points de terminaison pour répertorier, récupérer et supprimer des projets :

@app.get("/projects")
async def list_projects(): ...

@app.get("/projects/{project_id}")
async def get_project(project_id: str): ...

@app.delete("/projects/{project_id}")
async def delete_project(project_id: str): ...

‍

Vous pouvez les utiliser pour surveiller ou nettoyer l'espace de votre projet.

‍

Partie 5 : Ajouter des données au projet

‍

Téléchargement de fichiers

@app.post("/projects/{project_id}/files")
async def upload_file(...):
    ...
    # You can either upload an actual file or just provide a file_url

‍

Cela déclenchera l'OCR (si nécessaire) et la génération de découpages et d'intégrations via Eden AI.

‍

Ajouter du texte ou des URL

@app.post("/projects/{project_id}/texts")
async def add_texts(...): ...
@app.post("/projects/{project_id}/urls")
async def add_urls(...): ...

‍

Cela est particulièrement utile pour ajouter des données par programmation, par exemple pour injecter du contenu de FAQ ou pour extraire des URL.

‍

Partie 6 : Création de profils de robots

‍

C'est ici que vous pouvez définir « personnalité » du chatbot ou de l'assistant :

class CreateBotProfileRequest(BaseModel):
    model: str
    name: str
    text: str
    params: Optional[Dict[str, Any]] = None

@app.post("/projects/{project_id}/bot-profile")
async def create_bot_profile(...): ...

‍

Il s'agit de l'invite de votre système qui indique au LLM comment se comporter. Vous pouvez également transmettre la température ou max_tokens via des paramètres.

‍

Partie 7 : Poser des questions (LLM + RAG)

class AskLLMRequest(BaseModel):
    query: str
    ...
    k: int = 3  # Number of relevant chunks to retrieve

@app.post("/projects/{project_id}/ask-llm")
async def ask_llm(...): ...

‍

Ce point de terminaison est au cœur du système RAG : il extrait les segments pertinents de la base de données vectorielle et les introduit dans le LLM en tant que contexte avant de répondre à votre requête.

‍

Partie 8 : Gérer les conversations

Pour prendre en charge les interfaces utilisateur basées sur le chat, nous gérons également les conversations :

@app.post("/projects/{project_id}/conversations")
async def create_conversation(...): ...

@app.get("/projects/{project_id}/conversations")
async def list_conversations(...): ...

‍

Vous pouvez également récupérer, supprimer ou poursuivre un fil de dialogue en cours à l'aide de l'historique.

‍

Partie 9 : Interrogation et suppression de données

Vous avez besoin de faire le ménage ?

@app.delete("/projects/{project_id}/chunks")
async def delete_chunks(...): ...

@app.delete("/projects/{project_id}/all-chunks")
async def delete_all_chunks(...): ...

‍

Vous pouvez également interroger les données directement :

@app.post("/projects/{project_id}/query")
async def query_data(...): ...

‍

Parfait pour les tableaux de bord d'administration ou les contrôles d'intégrité.

‍

Exemple de flux réel

‍

Supposons que vous souhaitiez créer un assistant de documentation juridique :

1. Création d'un projet RAG avec OpenAI et Qdrant.
2. Téléchargez vos documents juridiques (PDF, texte, URL).
3. Création d'un profil de bot demander à l'IA de se comporter comme un expert juridique.
4. Posez des questions comme « Quelles clauses de ce contrat s'appliquent à la propriété intellectuelle ? »
5. Récupérez et discutez avec un contexte complet, des citations et une assistance de suivi.

‍

Conclusion

La génération assistée par extraction est la prochaine évolution de la façon dont nous interagissons avec l'IA. En combinant l'extraction structurée des connaissances avec de puissants LLM, nous offrons à nos applications superpuissances—de la recherche de documents juridiques aux chatbots de support client, en passant par les assistants de recherche personnalisés.

Ce blog et notre [tutoriel YouTube] vous fournissent tout ce dont vous avez besoin pour démarrer. Que vous créiez des outils pour le travail, l'école ou les loisirs, un backend RAG solide comme celui-ci constitue votre base.

Si vous en voulez plus, envisagez de l'étendre à :

• Une application complète avec une interface React/Vue.
• Prise en charge de la transcription audio et des pipelines d'OCR.
• Balisage et filtrage personnalisés des métadonnées.

Vous voulez la procédure pas à pas complète avec voix, images et débogage étape par étape ? Regardez le tutoriel complet sur notre chaîne YouTube.