Vos utilisateurs métier veulent des réponses. Pas des cours de SQL. Le Text-to-SQL permet d'interroger une base de données relationnelle en posant une question en langage naturel — et d'obtenir la requête SQL correspondante, générée automatiquement par un LLM. Fini les allers-retours avec l'équipe data pour un simple reporting.
Avec l'essor de l'IA générative, les approches modernes combinent des LLM (GPT-4, Claude, Mistral) avec des techniques de RAG (Retrieval-Augmented Generation) pour atteindre des taux de précision de 70 à 85 % sur des schémas complexes — et bien plus avec un entraînement ciblé. Dans cet article, on passe du concept au code : vous allez construire deux pipelines Text-to-SQL fonctionnels, l'un avec Vanna AI, l'autre avec LangChain, et comprendre les briques techniques qui font la différence en production.
Si vous travaillez sur des projets de croisement de données structurées et non structurées, le Text-to-SQL est une pièce maîtresse de votre stack.
Un pipeline Text-to-SQL moderne ne se limite pas à envoyer une question à un LLM. L'architecture repose sur trois étapes clés qui transforment une question vague en une requête SQL valide et exécutable.
Le schema linking identifie les tables et colonnes pertinentes pour une question donnée. C'est l'étape critique : sans elle, le LLM hallucine des noms de colonnes ou génère des JOIN incorrects. En pratique, on fournit au modèle le DDL (Data Definition Language) des tables, enrichi de descriptions métier.
Plutôt que de compter uniquement sur la capacité du LLM à générer du SQL, on lui fournit des exemples de paires question/SQL similaires à la requête en cours. C'est le principe du RAG appliqué au Text-to-SQL : on stocke des exemples dans un vector store, on retrouve les plus proches par similarité sémantique, et on les injecte dans le prompt. Cette approche réduit significativement les hallucinations et améliore la gestion des conventions spécifiques à votre schéma.
Le SQL généré est exécuté contre la base, et le résultat est renvoyé à l'utilisateur — ou au LLM pour une reformulation en langage naturel. Les agents les plus avancés intègrent une boucle de retry automatique : si la requête échoue, l'agent analyse l'erreur et corrige le SQL. C'est exactement ce que proposent les SQL Agents de LangChain.
Ce type d'architecture est au coeur des solutions d'IA générative que nous déployons chez Flowt, notamment pour les PME et ETI qui veulent démocratiser l'accès à leurs données sans multiplier les licences BI.
Vanna AI est un framework Python open source conçu spécifiquement pour le Text-to-SQL. Son approche RAG native en fait un excellent point de départ : vous entraînez un modèle sur votre schéma, vos requêtes existantes et votre documentation métier, puis vous interrogez en langage naturel.
Installez Vanna avec les dépendances ChromaDB et OpenAI :
```bash pip install 'vanna[chromadb,openai]' ```
Créez ensuite votre instance Vanna en combinant un LLM et un vector store. Vanna utilise l'héritage multiple pour assembler les briques :
```python from vanna.openai.openai_chat import OpenAI_Chat from vanna.chromadb.chromadb_vector import ChromaDB_VectorStore class MyVanna(ChromaDB_VectorStore, OpenAI_Chat): def __init__(self, config=None): ChromaDB_VectorStore.__init__(self, config=config) OpenAI_Chat.__init__(self, config=config) vn = MyVanna(config={ 'api_key': 'sk-votre-cle-openai', 'model': 'gpt-4o' }) ```
Connectez Vanna à une base SQLite et entraînez le modèle sur le schéma. L'entraînement consiste à indexer le DDL, la documentation métier et des exemples de requêtes SQL dans le vector store :
```python # Connexion à la base SQLite vn.connect_to_sqlite('ecommerce.db') # Entraînement automatique sur le schéma DDL df_ddl = vn.run_sql( "SELECT type, sql FROM sqlite_master WHERE sql IS NOT NULL" ) for ddl in df_ddl['sql'].to_list(): vn.train(ddl=ddl) # Ajout de documentation métier vn.train(documentation=""" Le champ 'ca_ttc' représente le chiffre d'affaires TTC en euros. La table 'commandes' contient une ligne par commande client. Le statut 'LIVRE' indique une commande livrée avec succès. """) # Ajout d'exemples de requêtes SQL (few-shot) vn.train(sql=""" SELECT client_id, SUM(ca_ttc) AS ca_total FROM commandes WHERE statut = 'LIVRE' GROUP BY client_id ORDER BY ca_total DESC LIMIT 10 """) ```
Une fois entraîné, Vanna retrouve les exemples les plus pertinents par similarité sémantique et génère la requête SQL :
```python # Poser une question en français resultat = vn.ask( question="Quel est le top 5 des clients par chiffre d'affaires ce trimestre ?" ) print(resultat) ```
La méthode ask() retourne à la fois la requête SQL générée et le DataFrame résultant. En coulisses, Vanna exécute le pipeline complet : retrieval des exemples similaires, construction du prompt, appel au LLM, exécution SQL, et retour du résultat.
Pour aller plus loin dans la compréhension des données textuelles qui alimentent ce type de pipeline, consultez notre article sur le NLP en entreprise.
Là où Vanna propose une solution intégrée, LangChain offre une approche modulaire basée sur des agents. Un SQL Agent peut inspecter le schéma, générer du SQL, exécuter la requête, analyser les erreurs et retenter automatiquement — le tout de manière autonome.
Installez les packages nécessaires :
```bash pip install langchain langchain-community langchain-openai ```
Connectez LangChain à votre base de données via le wrapper SQLDatabase de SQLAlchemy :
```python from langchain_community.utilities import SQLDatabase db = SQLDatabase.from_uri("sqlite:///ecommerce.db") print(f"Dialect : {db.dialect}") print(f"Tables disponibles : {db.get_usable_table_names()}") ```
Le SQL Agent combine un LLM, un toolkit de requêtage et un prompt système qui encadre le comportement de l'agent :
```python from langchain_openai import ChatOpenAI from langchain_community.agent_toolkits import create_sql_agent llm = ChatOpenAI(model="gpt-4o", temperature=0) agent = create_sql_agent( llm=llm, db=db, agent_type="tool-calling", verbose=True ) # Interrogation en langage naturel response = agent.invoke({ "input": "Quels sont les 5 produits les plus vendus ce mois-ci ?" }) print(response["output"]) ```
L'agent exécute plusieurs étapes en autonomie : il liste d'abord les tables, inspecte le schéma des tables pertinentes, génère la requête SQL, l'exécute, et formule la réponse. Si le SQL échoue, il analyse le message d'erreur et corrige automatiquement.
Pour adapter l'agent à votre contexte métier, personnalisez le prompt système. C'est ici que vous injectez les conventions de nommage, les règles de filtrage et les contraintes spécifiques :
```python system_prompt = """Tu es un expert SQL pour une base e-commerce française. Règles : - Utilise toujours des alias explicites pour les colonnes - Les montants sont en euros TTC (colonne ca_ttc) - Filtre par statut = 'LIVRE' pour les commandes confirmées - Limite les résultats à {top_k} lignes sauf indication contraire - Réponds en français Dialect SQL : {dialect} """.format(dialect=db.dialect, top_k=10) agent = create_sql_agent( llm=llm, db=db, agent_type="tool-calling", system_message=system_prompt, verbose=True ) ```
Cette approche par agent est particulièrement puissante lorsque vous avez un schéma complexe avec de nombreuses tables. L'agent choisit dynamiquement quelles tables inspecter, ce qui économise des tokens et améliore la précision. Pour structurer votre schéma en amont, la mise en place de contrats de données est un prérequis recommandé.
Les deux approches répondent à des besoins différents. Voici un comparatif pour vous aider à trancher :
Dans les deux cas, la qualité des métadonnées (DDL, documentation métier, exemples SQL) détermine 80 % de la performance. Un schéma bien documenté, avec des noms de colonnes explicites et une documentation des règles métier, surpasse systématiquement un modèle plus puissant sur un schéma opaque.
C'est aussi pour cette raison qu'un catalogue de données comme DataGalaxy peut considérablement améliorer vos résultats Text-to-SQL : plus votre schéma est documenté, plus le LLM est précis.
Passer d'un notebook à un système en production nécessite de traiter plusieurs problématiques que le prototypage ne révèle pas.
Le LLM peut générer des requêtes DELETE, DROP ou UPDATE. En production, connectez votre pipeline à un utilisateur en lecture seule sur la base de données. C'est non négociable.
Loguez systématiquement la question utilisateur, le SQL généré, le résultat retourné et le temps d'exécution. Ces logs alimentent votre boucle d'amélioration : les requêtes échouées deviennent vos prochains exemples d'entraînement.
Le Text-to-SQL ne remplace pas un analyste. Les requêtes impliquant des sous-requêtes corrélées complexes, des fonctions fenêtre imbriquées ou des jointures sur plus de 5 tables restent sujettes à erreur. Prévoyez un fallback clair : si la confiance du modèle est faible, redirigez vers un humain plutôt que de retourner un résultat faux.
Implémentez une boucle de feedback où les utilisateurs valident ou corrigent les résultats. Chaque correction enrichit votre base d'exemples few-shot et améliore le RAG. C'est le même principe d'itération que celui décrit dans notre guide sur la prédiction du churn par Machine Learning : la performance vient de la donnée, pas seulement du modèle.
Pour les équipes qui souhaitent visualiser les résultats de leurs requêtes Text-to-SQL, la combinaison avec des outils comme Metabase ou Streamlit permet de créer des dashboards alimentés en langage naturel.
Le Text-to-SQL propulsé par l'IA générative ouvre l'accès aux données à l'ensemble de l'organisation — sans sacrifier la rigueur technique. Que vous choisissiez Vanna AI pour sa simplicité ou LangChain pour sa flexibilité, la clé du succès réside dans la qualité de votre couche de métadonnées et dans une mise en production maîtrisée.
Chez Flowt, nous accompagnons les PME et ETI dans le déploiement de solutions Data Science et IA sur mesure — du POC en 4 semaines à l'industrialisation complète. Si vous souhaitez évaluer le potentiel du Text-to-SQL sur vos données, demandez un audit IA gratuit ou contactez notre équipe.
Vous souhaitez être accompagné pour lancer votre projet Data ou IA ?
Perplexity
ChatGPT
Claude
Grok
Gemini
Mistral
.jpg)
.jpg)
