LLM et graphes de connaissances

📖 Introduction

Les LLM (Large Language Models) comme GPT-4, Mistral ou Llama sont exceptionnels pour comprendre et générer du texte. Mais ils ont une faiblesse majeure : ils ne savent pas raisonner sur des relations complexes ni vérifier leurs faits en temps réel.

🎯 Pourquoi combiner LLM et graphes ?

Ce que les LLM seuls ne savent pas faire

• ❌ Raisonner sur des relations complexes (transitivité, cycles, chemins)
• ❌ Vérifier leurs sources (hallucinations)
• ❌ Mettre à jour leurs connaissances (connaissance figée)
• ❌ Expliquer leur raisonnement (boîte noire)
• ❌ Gérer des données hétérogènes (SQL, documents, APIs)

Ce que le graphe apporte au LLM

• ✅ Faits vérifiables : le LLM ne "devine" plus
• ✅ Connaissance à jour : le graphe peut être mis à jour sans réentraînement
• ✅ Raisonnement relationnel : inférences, chemins, transitivité
• ✅ Sources citables : chaque fait a son origine
• ✅ Explicabilité : le chemin dans le graphe explique la réponse

🏗️ Architectures d'intégration

1. RAG (Retrieval-Augmented Generation)

Le LLM interroge le graphe à la volée pour chaque requête.

2. KG-Augmented Fine-tuning

On utilise le graphe pour enrichir les données d'entraînement du LLM.

3. Graph-based Reasoning (Agent)

Le LLM agit comme un agent qui navigue dans le graphe.

🤖 LLM supportés

💻 Implémentation pratique

Avec LangChain et Neo4j

from langchain.chains import GraphCypherQAChain
from langchain_community.graphs import Neo4jGraph
from langchain_openai import ChatOpenAI

# Connexion au graphe Neo4j
graph = Neo4jGraph(
    url="bolt://localhost:7687",
    username="neo4j",
    password="password"
)

# LLM (GPT-4, Mistral, etc.)
llm = ChatOpenAI(model="gpt-4", temperature=0)

# Chaîne RAG sur graphe
chain = GraphCypherQAChain.from_llm(
    graph=graph,
    llm=llm,
    verbose=True,
    return_intermediate_steps=True
)

# Question
result = chain.invoke(
    "Quels discours de Charles de Gaulle parlent de la résistance ?"
)
print(result["result"])
print(result["intermediate_steps"])  # Affiche la requête Cypher générée

Avec RDF et SPARQL

from langchain.chains import GraphSparqlQAChain
from langchain_community.graphs import RdfGraph
from langchain_openai import ChatOpenAI

# Connexion au triple store
graph = RdfGraph(
    query_endpoint="http://localhost:3030/ds/sparql",
    update_endpoint="http://localhost:3030/ds/update"
)

chain = GraphSparqlQAChain.from_llm(
    graph=graph,
    llm=ChatOpenAI(model="gpt-4")
)

result = chain.invoke("Qui a prononcé l'Appel du 18 juin ?")

Version locale avec Ollama + Neo4j

from langchain_community.llms import Ollama
from langchain.chains import GraphCypherQAChain

# LLM local (Mistral, Llama)
llm = Ollama(model="mistral", temperature=0)

chain = GraphCypherQAChain.from_llm(
    graph=graph,
    llm=llm,
    verbose=True
)

result = chain.invoke("Quels sont les discours de Victor Hugo ?")

🧠 Raisonnement augmenté par graphe

Les LLM seuls échouent sur les tâches de raisonnement relationnel. Le graphe résout ce problème.

🎯 Cas d'usage concrets

1. Recherche documentaire augmentée

Un LLM qui interroge un graphe de documents (relations de citation, référence, dépendance).

2. Assistant juridique

Navigation dans les lois, arrêts, jurisprudences avec leurs relations (abroge, modifie, cite).

3. Support client produit

LLM + graphe de produits (compatibilités, alternatives, composants).

4. Gestion des connaissances d'entreprise

LLM + graphe des employés, projets, compétences, documents.

5. Patrimoine culturel (notre cas)

LLM + graphe des discours, orateurs, événements historiques.

📚 Ressources pour aller plus loin

• 🤖 RAG avec graphes de connaissances
• ⚖️ RAG vs Fine-tuning
• LangChain Graph documentation
• Ollama - LLM local
• Documentation Cypher (Neo4j)