Construire votre premier agent simple
Suivez un guide étape par étape pour configurer votre environnement et construire un agent d’intelligence artificielle élémentaire avec LangChain.
Construire votre premier agent simple est une leçon AI Agents with LangChain & Autonomous Workflows gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Agents with LangChain & Autonomous Workflows, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Agents with LangChain & Autonomous Workflows comprend 4 leçons au total.
Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.
Build Your First Agent!
Time to build your first AI agent with LangChain — connecting an LLM to basic tools so it can answer your queries intelligently.
Set Up Your Python Environment
First, set up Python 3.9+ and a virtual environment to isolate dependencies. Create one with venv, then activate it before you install anything.
Install LangChain & Dependencies
Now install LangChain and the OpenAI integration. Run the pip command inside your activated virtual environment.
Connect to an LLM
Your agent needs a brain. Initialize ChatOpenAI with your API key stored as the OPENAI_API_KEY environment variable — never hardcode it.
import os
from langchain_openai import ChatOpenAI
def main():
# In a real setup, ensure OPENAI_API_KEY is set
# For demonstration, we'll assume it's available
# os.environ["OPENAI_API_KEY"] = "sk-..." # DON'T hardcode!
try:
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
print("LLM initialized successfully!")
# You can test it:
# response = llm.invoke("Hello, LLM!")
# print(response.content)
except Exception as e:
print(f"Error initializing LLM: {e}")
print("Please ensure OPENAI_API_KEY is set.")
if __name__ == "__main__":
main()Agents Need Tools
An agent is an LLM plus tools — functions or APIs that let it act on the world: search, run code, calculate. Here we give ours a calculator.
import os
from langchain_openai import ChatOpenAI
from langchain.tools import Tool
from langchain_community.utilities import LLMMathChain
def main():
# Ensure OPENAI_API_KEY is set
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
# Create a basic math tool
llm_math_chain = LLMMathChain.from_llm(llm)
math_tool = Tool.from_function(
func=llm_math_chain.run,
name="Calculator",
description="Useful for when you need to answer questions about math."
)
tools = [math_tool]
print("Basic math tool created and ready!")
if __name__ == "__main__":
main()Choosing Your Agent Type
The agent type defines how it reasons. We'll use create_react_agent — ReAct means Reason and Act: it plans, observes results, then refines.
Combining Components
Now combine the pieces: create_react_agent takes your LLM, tools, and prompt to build the logic, then AgentExecutor wraps it to make it runnable.
import os
from langchain_openai import ChatOpenAI
from langchain.tools import Tool
from langchain_community.utilities import LLMMathChain
from langchain.agents import AgentExecutor, create_react_agent
from langchain_core.prompts import ChatPromptTemplate
def main():
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
llm_math_chain = LLMMathChain.from_llm(llm)
math_tool = Tool.from_function(
func=llm_math_chain.run,
name="Calculator",
description="Useful for when you need to answer questions about math."
)
tools = [math_tool]
# Define the prompt for the agent
prompt = ChatPromptTemplate.from_messages([
("system", "You are a helpful AI assistant. Use tools when necessary."),
("human", "{input}"),
("placeholder", "{agent_scratchpad}")
])
# Create the agent
agent = create_react_agent(llm, tools, prompt)
# Create the agent executor
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
print("Agent assembled and ready for action!")
if __name__ == "__main__":
main()Asking Your Agent a Question
With the agent assembled, give it a task via invoke. Ask a math question and watch it reach for its calculator tool to answer.
import os
from langchain_openai import ChatOpenAI
from langchain.tools import Tool
from langchain_community.utilities import LLMMathChain
from langchain.agents import AgentExecutor, create_react_agent
from langchain_core.prompts import ChatPromptTemplate
def main():
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
llm_math_chain = LLMMathChain.from_llm(llm)
math_tool = Tool.from_function(
func=llm_math_chain.run,
name="Calculator",
description="Useful for when you need to answer questions about math."
)
tools = [math_tool]
prompt = ChatPromptTemplate.from_messages([
("system", "You are a helpful AI assistant. Use tools when necessary."),
("human", "{input}"),
("placeholder", "{agent_scratchpad}")
])
agent = create_react_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
print("Asking the agent: 'What is 123 multiplied by 456?'")
response = agent_executor.invoke({"input": "What is 123 multiplied by 456?"})
print("\nAgent's final answer:")
print(response["output"])
if __name__ == "__main__":
main()Understanding the Agent's Response
With verbose=True you see the agent's thought process: Thought, Action, Action Input, Observation, then Final Answer. That transparency is key to debugging.
Your Complete First Agent!
Here's your complete first agent. Set your API key, run it, and try changing the input question to see it reason through different problems.
import os
from langchain_openai import ChatOpenAI
from langchain.tools import Tool
from langchain_community.utilities import LLMMathChain
from langchain.agents import AgentExecutor, create_react_agent
from langchain_core.prompts import ChatPromptTemplate
def main():
# 1. Set up your LLM
# Ensure OPENAI_API_KEY is set as an environment variable
# os.environ["OPENAI_API_KEY"] = "YOUR_KEY_HERE" # DO NOT hardcode!
try:
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
except Exception as e:
print(f"Error: {e}. Please ensure OPENAI_API_KEY is set.")
return
# 2. Define your tools
llm_math_chain = LLMMathChain.from_llm(llm)
math_tool = Tool.from_function(
func=llm_math_chain.run,
name="Calculator",
description="Useful for when you need to answer questions about math."
)
tools = [math_tool]
# 3. Define the agent's prompt
prompt = ChatPromptTemplate.from_messages([
("system", "You are a helpful AI assistant. Use tools when necessary."),
("human", "{input}"),
("placeholder", "{agent_scratchpad}")
])
# 4. Create the agent
agent = create_react_agent(llm, tools, prompt)
# 5. Create the AgentExecutor
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
# 6. Run the agent
print("\n--- Running the Agent ---")
question = "What is the square root of 144 plus 25?"
print(f"Agent input: '{question}'")
response = agent_executor.invoke({"input": question})
print("\n--- Agent's Final Answer ---")
print(response["output"])
if __name__ == "__main__":
main()Agent Components Check
You've seen how to build a basic agent. Which of the following are essential components when constructing a LangChain agent using create_react_agent?
Recap: Your First Agent!
Recap: you built a real agent — set up the environment, connected an LLM, added a tool, assembled it with create_react_agent and AgentExecutor, and watched it think.
Apprends AI Agents with LangChain & Autonomous Workflows avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 12
- Leçons
- 50
Questions Fréquemment Posées
La leçon « Construire votre premier agent simple » est-elle gratuite ?
Oui — le texte complet de « Construire votre premier agent simple » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Agents with LangChain & Autonomous Workflows, passe à CoddyKit PRO. Le cours AI Agents with LangChain & Autonomous Workflows comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Construire votre premier agent simple » ?
Suivez un guide étape par étape pour configurer votre environnement et construire un agent d’intelligence artificielle élémentaire avec LangChain. Tu pratiques AI Agents with LangChain & Autonomous Workflows avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer AI Agents with LangChain & Autonomous Workflows ?
Aucune expérience préalable n'est requise. AI Agents with LangChain & Autonomous Workflows sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.
Combien de temps prend la leçon « Construire votre premier agent simple » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon AI Agents with LangChain & Autonomous Workflows ?
Oui. Chaque leçon AI Agents with LangChain & Autonomous Workflows inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Comprendre les agents d’intelligence artificielle et les LLM
- Explication des composants fondamentaux de LangChain
- Construire votre premier agent simple
- Doter les agents d’une mémoire et d’un état conversationnel