LangChain débutant : créer son premier agent IA en Python

# Créer un environnement virtuel
python -m venv .venv
source .venv/bin/activate # Linux/Mac
.venv\Scripts\activate # Windows

# Installer LangChain et ses dépendances
pip install langchain langchain-openai langchain-community python-dotenv

# Créer le fichier .env
echo "OPENAI_API_KEY=votre-cle-api-ici" > .env

from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, SystemMessage

load_dotenv()

# Initialiser le modèle
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

# Premier appel
messages = [
  SystemMessage(content="Tu es un assistant expert en IA pour PME."),
  HumanMessage(content="Qu'est-ce qu'un agent IA en 2 phrases ?")
]

reponse = llm.invoke(messages)
print(reponse.content)

from langchain_core.prompts import ChatPromptTemplate

# Créer un template de prompt réutilisable
template = ChatPromptTemplate.from_messages([
  ("system", "Tu es un expert en {domaine}. Réponds en français, concis."),
  ("human", "{question}")
])

# Chaîner le template avec le modèle (LCEL - LangChain Expression Language)
chaine = template | llm

# Utiliser la chaîne
reponse = chaine.invoke({
  "domaine": "cybersécurité pour PME",
  "question": "Quelles sont les 3 menaces IA les plus courantes ?"
})
print(reponse.content)

from langchain_core.chat_history import InMemoryChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory

# Stocker l'historique en mémoire
historiques = {}

def obtenir_historique(session_id: str):
  if session_id not in historiques:
    historiques[session_id] = InMemoryChatMessageHistory()
  return historiques[session_id]

# Ajouter la mémoire à la chaîne
chaine_avec_memoire = RunnableWithMessageHistory(
  chaine,
  obtenir_historique,
  input_messages_key="question",
  history_messages_key="history"
)

# Conversation avec mémoire
config = {"configurable": {"session_id": "user_1"}}
rep1 = chaine_avec_memoire.invoke({"question": "Je m'appelle Marc."}, config)
rep2 = chaine_avec_memoire.invoke({"question": "Comment je m'appelle ?"}, config)
print(rep2.content) # → "Vous vous appelez Marc."

from langchain_community.document_loaders import TextLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import Chroma
from langchain.chains import RetrievalQA

# 1. Charger vos documents
loader = TextLoader("ma_documentation.txt", encoding="utf-8")
documents = loader.load()

# 2. Découper en chunks
splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
chunks = splitter.split_documents(documents)

# 3. Créer la base vectorielle
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(chunks, embeddings)

# 4. Créer la chaîne RAG
qa_chain = RetrievalQA.from_chain_type(
  llm=llm,
  retriever=vectorstore.as_retriever(search_kwargs={"k": 3}),
  return_source_documents=True
)

# 5. Interroger vos documents
resultat = qa_chain.invoke({"query": "Quelle est notre politique de remboursement ?"})
print(resultat["result"])
print(resultat["source_documents"]) # Sources citées

from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain_core.tools import tool

# Définir des outils personnalisés
@tool
def calculer_tva(montant_ht: float) -> str:
  """Calcule le montant TTC à partir d'un montant HT (TVA 20%)."""
  tva = montant_ht * 0.20
  ttc = montant_ht + tva
  return f"HT: {montant_ht}€, TVA: {tva:.2f}€, TTC: {ttc:.2f}€"

@tool
def rechercher_client(nom: str) -> str:
  """Recherche un client dans la base de données par nom."""
  # En production : requête SQL ou API CRM
  clients = {"Dupont": "SARL Dupont, 10 rue de Paris, CA: 500k€"}
  return clients.get(nom, "Client non trouvé")

outils = [calculer_tva, rechercher_client]

# Créer le prompt de l'agent
prompt = ChatPromptTemplate.from_messages([
  ("system", "Tu es un assistant commercial pour PME. Utilise les outils disponibles."),
  ("human", "{input}"),
  ("placeholder", "{agent_scratchpad}")
])

# Créer et lancer l'agent
agent = create_tool_calling_agent(llm, outils, prompt)
executor = AgentExecutor(agent=agent, tools=outils, verbose=True)

resultat = executor.invoke({"input": "Quel est le TTC pour un devis de 2500€ HT ?"})
print(resultat["output"])

pip install langchain-ollama

from langchain_ollama import ChatOllama

# Remplacer OpenAI par Ollama — aucune autre modification nécessaire !
llm_local = ChatOllama(model="qwen2.5:14b", base_url="http://localhost:11434")

# Tout le reste du code fonctionne identiquement

LANGCHAIN_TRACING_V2=true
LANGCHAIN_API_KEY=votre-cle-langsmith
LANGCHAIN_PROJECT=mon-projet-pme