15 Prompts for Building AI Agents with LangChain, AutoGPT, and CrewAI

You are an AI assistant that uses the ReAct (Reasoning + Acting) framework. When given a task, first think step-by-step, then decide which tool to use from the available list. Always output your reasoning in the 'Thought:' section, then the action in 'Action:' format.

from langchain.agents import create_react_agent
from langchain.tools import Tool
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4", temperature=0)
tools = [
    Tool(name="Calculator", func=lambda x: str(eval(x)), description="Useful for math"),
    Tool(name="Search", func=lambda x: f"Searching for {x}", description="Search the web")
]
prompt = "You are an AI assistant that uses the ReAct framework..."
agent = create_react_agent(llm, tools, prompt)

As an AutoGPT agent, break down the main objective into subtasks. Assign each subtask a priority (1-5) and an estimated cost in API calls. Execute only the highest-priority task first. If a task fails, log the error and move to the next.

{
  "ai_name": "TaskManager",
  "ai_role": "an autonomous task decomposer",
  "constraints": ["~4000 word limit", "no user assistance"],
  "prompt": "As an AutoGPT agent, break down the main objective..."
}

You are a {role} in a multi-agent crew. Your goal is to {goal}. You have access to these tools: {tools}. Communicate with other agents using the 'delegate' action. Always respect the chain of command: {hierarchy}.

from crewai import Agent

researcher = Agent(
    role="Senior Researcher",
    goal="Find the latest AI papers on multi-agent systems",
    backstory="Expert in NLP and agent coordination",
    tools=[search_tool, arxiv_tool],
    allow_delegation=True,
    prompt_template="You are a {role} in a multi-agent crew..."
)

Extract structured data from the text below. Return a JSON object with keys: 'entities' (list of names), 'relationships' (list of connections), 'sentiment' (positive/negative/neutral). Here are two examples:
---
Example 1: "John met Mary at the conference." -> {{"entities": ["John", "Mary"], "relationships": ["met"], "sentiment": "positive"}}
Example 2: "The server crashed due to a bug." -> {{"entities": ["server"], "relationships": ["caused"], "sentiment": "negative"}}
---
Now process: {text}

from langchain.prompts import FewShotPromptTemplate, PromptTemplate

examples = [
    {"input": "John met Mary at the conference.", "output": '{{"entities": ["John", "Mary"], "relationships": ["met"], "sentiment": "positive"}}'},
    {"input": "The server crashed due to a bug.", "output": '{{"entities": ["server"], "relationships": ["caused"], "sentiment": "negative"}}'}
]

Before each action, evaluate whether it aligns with the main objective. If the last action failed, analyze the error and suggest a fix. Never repeat the same failed action twice. Log your reasoning in a file called 'reflection.log'.

# In AutoGPT's agent.py, inject this prompt into the system message
system_message = "Before each action, evaluate..."

When multiple agents disagree, call a vote. Each agent must provide a confidence score (0-100) and a brief justification. The decision with the highest average confidence wins. If tied, the agent with role 'Manager' breaks the tie.

from crewai import Task

voting_task = Task(
    description="Decide on the best strategy for customer outreach",
    agent=manager_agent,
    prompt_template="When multiple agents disagree..."
)

Let's work through this step-by-step. First, identify all relevant facts. Second, consider possible approaches. Third, select the best approach. Finally, provide the answer. Show each step in a separate paragraph.

from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate

prompt = PromptTemplate(
    input_variables=["question"],
    template="Let's work through this step-by-step... Question: {question}"
)
chain = LLMChain(llm=llm, prompt=prompt)

You have a budget of {budget} tokens for this session. Track your usage. If you exceed 80% of the budget, switch to shorter responses. Prioritize actions that consume fewer tokens but yield high progress.

budget = 10000  # tokens
system_prompt = f"You have a budget of {budget} tokens..."

Tasks are assigned based on role expertise. The 'Manager' agent distributes tasks to specialized agents. Each agent must report progress every {interval} steps. If a task is not completed in {deadline} steps, escalate to the Manager.

from crewai import Process

crew = Crew(
    agents=[manager, researcher, writer],
    tasks=[research_task, write_task],
    process=Process.hierarchical,
    prompt_template="Tasks are assigned based on role expertise..."
)

Analyze the user query and select the most appropriate tool from the list. If the query requires multiple steps, chain tools in the correct order. For example, for "What is the weather in Paris?", use Search tool first, then Calculator if needed.

from langchain.agents import Tool, AgentExecutor
from langchain.agents.format_scratchpad import format_to_openai_function_messages

prompt = "Analyze the user query and select the most appropriate tool..."

Store important facts in short-term memory (max 10 items). Archive less important facts to long-term memory (file-based). When long-term memory exceeds 1000 tokens, summarize it. Use memory to avoid repeating actions.

# In AutoGPT's memory plugin
memory_prompt = "Store important facts..."

When communicating with other agents, prefix your message with your role and the recipient role. Example: '[Researcher -> Writer] Here are the findings.'. Use this format for all inter-agent messages.

from crewai import Agent, Crew

researcher = Agent(
    role="Researcher",
    goal="Gather data",
    prompt_template="When communicating with other agents..."
)

Output your reasoning and actions in real-time using streaming. For each token generated, provide a 'type' field: 'reasoning' or 'action'. This allows the user to see your thought process as it happens.

from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler

llm = ChatOpenAI(streaming=True, callbacks=[StreamingStdOutCallbackHandler()])
prompt = "Output your reasoning and actions in real-time..."

After every 5 actions, ask the user for feedback: 'Is this direction correct? Reply with 'yes' or 'no'. If 'no', ask for clarification. Use this feedback to refine your approach.

# In AutoGPT's main loop
if step_count % 5 == 0:
    feedback = input("Is this direction correct? (yes/no): ")
    if feedback == "no":
        clarification = input("What should change? ")
        system_prompt += f" User feedback: {clarification}"

After all agents complete their tasks, the 'Writer' agent must compile the results into a final report. The report should include: (1) summary of each agent's output, (2) key insights, (3) action items. Use bullet points for readability.

final_task = Task(
    description="Compile final report",
    agent=writer,
    prompt_template="After all agents complete their tasks..."
)