You: Research the current state of nuclear fusion energy. Focus on recent breakthroughs.
Agent: I'll research nuclear fusion energy breakthroughs for you. [Searching: "nuclear fusion breakthrough 2026"] [Searching: "ITER fusion reactor progress"] [Searching: "private fusion companies funding"]
Based on my research, here are the key findings:
Recent Breakthroughs
Commonwealth Fusion achieved net energy gain...
ITER completed first plasma tests...
Key Companies
Helion Energy: $2.2B funding, targeting 2028...
TAE Technologies: Reached 75 million degrees...
Shall I save these notes or dive deeper into any area?

Agent = LLM + Tools + Memory + Goal

┌─────────────────────────────────────────┐
│                                         │
│   ┌──────────┐    ┌──────────┐         │
│   │ PERCEIVE │───▶│  THINK   │         │
│   └──────────┘    └──────────┘         │
│        ▲               │               │
│        │               ▼               │
│   ┌──────────┐    ┌──────────┐         │
│   │  LEARN   │◀───│   ACT    │         │
│   └──────────┘    └──────────┘         │
│                                         │
└─────────────────────────────────────────┘

Python 3.9+
langchain
langchain-anthropic
langchain-community
duckduckgo-search
python-dotenv

# Create project directory
mkdir research-agent
cd research-agent
Create virtual environment
python -m venv venv
Activate it (Windows)
venv\Scripts\activate
Activate it (macOS/Linux)
source venv/bin/activate

langchain>=0.1.0
langchain-anthropic>=0.1.0
langchain-community>=0.0.20
duckduckgo-search>=4.0.0
python-dotenv>=1.0.0

pip install -r requirements.txt

ANTHROPIC_API_KEY=your-api-key-here

.env
venv/
__pycache__/
*.pyc
research_notes.json

research-agent/
├── venv/
├── .env
├── .gitignore
└── requirements.txt

"""
Personal Research Assistant Agent
A beginner-friendly AI agent that can search, take notes, and summarize.
"""
import os from dotenv import load_dotenv from langchain_anthropic import ChatAnthropic from langchain.agents import AgentExecutor, create_tool_calling_agent from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder from langchain_core.messages import HumanMessage, AIMessage
Load environment variables from .env file
load_dotenv()
Initialize the LLM (Claude)
We use claude-3-5-sonnet because it balances capability and cost
llm = ChatAnthropic(
    model="claude-sonnet-4-20250514",
    temperature=0.7,  # Slightly creative but still focused
    max_tokens=4096   # Enough for detailed responses
)
Define the agent's personality and instructions
SYSTEM_PROMPT = """You are a helpful Personal Research Assistant. Your job is to help users
research topics thoroughly and organize their findings.
Your capabilities: 
Search the web for current information
Take notes on important findings
Summarize and synthesize information
Remember previous conversations in this session

Guidelines: 
Always cite your sources when presenting research
If you're unsure about something, say so
Break complex topics into digestible sections
Ask clarifying questions if the research request is vague
Proactively suggest related topics the user might find interesting

When researching: 
First, understand what the user wants to know
Search for relevant, recent information
Organize findings into clear sections
Highlight key insights and trends
Offer to dive deeper into specific areas
 """

Create the prompt template
MessagesPlaceholder allows for conversation history
prompt = ChatPromptTemplate.from_messages([
    ("system", SYSTEM_PROMPT),
    MessagesPlaceholder(variable_name="chat_history"),
    ("human", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad")
])

import json
from datetime import datetime
from langchain_core.tools import tool
from langchain_community.tools import DuckDuckGoSearchResults
Tool 1: Web Search
DuckDuckGo is free and doesn't require an API key
search = DuckDuckGoSearchResults(
    name="web_search",
    description="Search the web for current information. Use this when you need up-to-date facts, news, or research.",
    num_results=5
)
Tool 2: Note Taking
We'll store notes in a JSON file for persistence
NOTES_FILE = "research_notes.json"
def load_notes():     """Load existing notes from file."""     if os.path.exists(NOTES_FILE):         with open(NOTES_FILE, 'r') as f:             return json.load(f)     return {"notes": []}
def save_notes(notes_data):     """Save notes to file."""     with open(NOTES_FILE, 'w') as f:         json.dump(notes_data, f, indent=2)
@tool def take_note(title: str, content: str, tags: str = "") -> str:     """     Save a research note for future reference.
Args:         title: Brief title for the note         content: The note content to save         tags: Comma-separated tags for organization (optional)
Returns:         Confirmation message     """     notes_data = load_notes()
note = {         "id": len(notes_data["notes"]) + 1,         "title": title,         "content": content,         "tags": [t.strip() for t in tags.split(",") if t.strip()],         "created_at": datetime.now().isoformat()     }
notes_data["notes"].append(note)     save_notes(notes_data)
return f"Note saved: '{title}' (ID: {note['id']})"
@tool def view_notes(tag_filter: str = "") -> str:     """     View saved research notes.
Args:         tag_filter: Optional tag to filter notes (leave empty for all notes)
Returns:         Formatted list of notes     """     notes_data = load_notes()     notes = notes_data["notes"]
if not notes:         return "No notes saved yet."
# Filter by tag if specified     if tag_filter:         notes = [n for n in notes if tag_filter.lower() in [t.lower() for t in n["tags"]]]         if not notes:             return f"No notes found with tag: {tag_filter}"
# Format notes for display     output = []     for note in notes:         tags_str = ", ".join(note["tags"]) if note["tags"] else "none"         output.append(f""" 
 Note #{note['id']}: {note['title']} Tags: {tags_str} Created: {note['created_at'][:10]}

{note['content']} """)
return "\n".join(output)
@tool def clear_notes() -> str:     """     Clear all saved notes. Use with caution.
Returns:         Confirmation message     """     save_notes({"notes": []})     return "All notes have been cleared."
Tool 3: Summarization
This tool uses the LLM itself to summarize content
@tool
def summarize_text(text: str, style: str = "bullet_points") -> str:
    """
    Summarize a piece of text.
Args:         text: The text to summarize         style: Summary style - 'bullet_points', 'paragraph', or 'eli5' (explain like I'm 5)
Returns:         Summarized text     """     style_instructions = {         "bullet_points": "Summarize in 5-7 concise bullet points.",         "paragraph": "Summarize in a single, well-written paragraph.",         "eli5": "Explain this simply, as if to a curious 5-year-old."     }
instruction = style_instructions.get(style, style_instructions["bullet_points"])
# Use the LLM to generate the summary     summary_prompt = f"""Please summarize the following text. {instruction}
Text to summarize: {text}
Summary:"""
response = llm.invoke(summary_prompt)     return response.content
Collect all tools
tools = [search, take_note, view_notes, clear_notes, summarize_text]

from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory
Create a store for session histories
In production, you'd use Redis or a database
session_histories = {}
def get_session_history(session_id: str) -> ChatMessageHistory:     """     Get or create a chat history for a session.
This allows multiple users/sessions to have independent conversations.     """     if session_id not in session_histories:         session_histories[session_id] = ChatMessageHistory()     return session_histories[session_id]
Create the agent with tool-calling capability
agent = create_tool_calling_agent(llm, tools, prompt)
Create the agent executor (this runs the agent loop)
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    verbose=True,  # Set to True to see the agent's reasoning
    max_iterations=10,  # Prevent infinite loops
    handle_parsing_errors=True  # Gracefully handle LLM output issues
)
Wrap with message history for memory
agent_with_memory = RunnableWithMessageHistory(
    agent_executor,
    get_session_history,
    input_messages_key="input",
    history_messages_key="chat_history"
)

def chat(user_input: str, session_id: str = "default") -> str:
    """
    Send a message to the agent and get a response.
Args:         user_input: The user's message         session_id: Unique identifier for this conversation
Returns:         The agent's response     """     response = agent_with_memory.invoke(         {"input": user_input},         config={"configurable": {"session_id": session_id}}     )     return response["output"]
def main():     """Main function to run the interactive agent."""     print("=" * 60)     print("PERSONAL RESEARCH ASSISTANT")     print("=" * 60)     print("\nHello! I'm your Personal Research Assistant.")     print("I can search the web, take notes, and summarize information.")     print("\nCommands:")     print("  Type your research questions naturally")     print("  Type 'notes' to view saved notes")     print("  Type 'clear' to clear notes")     print("  Type 'quit' or 'exit' to end the session")     print("=" * 60)
session_id = f"session_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
while True:         try:             # Get user input             user_input = input("\nYou: ").strip()
# Handle exit commands             if user_input.lower() in ['quit', 'exit', 'q']:                 print("\nGoodbye! Your notes have been saved.")                 break
# Handle empty input             if not user_input:                 print("Please enter a question or command.")                 continue
# Quick commands             if user_input.lower() == 'notes':                 print("\n" + view_notes.invoke({"tag_filter": ""}))                 continue
if user_input.lower() == 'clear':                 print("\n" + clear_notes.invoke({}))                 continue
# Process with agent             print("\nAssistant: ", end="")             response = chat(user_input, session_id)             print(response)
except KeyboardInterrupt:             print("\n\nSession interrupted. Goodbye!")             break         except Exception as e:             print(f"\nError: {e}")             print("Please try again or rephrase your question.")
if __name__ == "__main__":     main()

python agent.py

You: What are the latest developments in AI agents in 2026?

You: Save a note about AI agents with the tag "ai"

You: Tell me more about the second point you mentioned

You: Research how solar panel efficiency has improved in the last 2 years.
     Focus on perovskite technology. Save any important findings.

> Entering new AgentExecutor chain...
Invoking: web_search with {'query': 'solar panel perovskite efficiency 2024 2025'}
[Search results appear here]
Thought: I found several relevant articles. Let me search for more specific data...
Invoking: web_search with {'query': 'perovskite solar cell efficiency record'}
...

@tool
def export_research(filename: str, title: str = "Research Notes") -> str:
    """
    Export all notes to a markdown file.
Args:         filename: Name for the export file (without extension)         title: Title for the document
Returns:         Confirmation with file path     """     notes_data = load_notes()
if not notes_data["notes"]:         return "No notes to export."
markdown = f"# {title}\n\n"     markdown += f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M')}\n\n"
for note in notes_data["notes"]:         markdown += f"## {note['title']}\n\n"         markdown += f"{note['content']}\n\n"         if note['tags']:             markdown += f"Tags: {', '.join(note['tags'])}\n\n"         markdown += "---\n\n"
filepath = f"{filename}.md"     with open(filepath, 'w') as f:         f.write(markdown)
return f"Research exported to: {filepath}"

@tool
def search_with_sources(query: str) -> str:
    """
    Search the web and return results with source URLs.
Args:         query: What to search for
Returns:         Search results with clickable sources     """     results = search.invoke(query)
# The agent can now cite these sources     return f"Search results for '{query}':\n\n{results}\n\nRemember to cite these sources in your response."

# This is a conceptual example - requires additional setup
import schedule
import time
def daily_research():     """Run automated daily research on predefined topics."""     topics = [         "AI agent frameworks news",         "Python library updates",     ]
for topic in topics:         response = chat(f"Quick search: {topic}", session_id="automated")         # Could email results or save to a file
schedule.every().day.at("09:00").do(daily_research)

# Better tool response for no results
if not results:
    return "No results found. Try a different search query or broader terms."

# Bad description
"""Search the web."""
Good description
"""Search the web for current information. Use this when you need up-to-date
facts, recent news, or information that might have changed since your training.
Do NOT use for general knowledge questions you already know."""

def get_session_history(session_id: str) -> ChatMessageHistory:
    if session_id not in session_histories:
        session_histories[session_id] = ChatMessageHistory()
history = session_histories[session_id]
# Keep only last 20 messages     if len(history.messages) > 20:         history.messages = history.messages[-20:]
return history

import time
from tenacity import retry, stop_after_attempt, wait_exponential
@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=4, max=60)) def chat_with_retry(user_input: str, session_id: str) -> str:     return chat(user_input, session_id)

SYSTEM_PROMPT = """...
IMPORTANT: Only state facts that come directly from your tool results.
If you cannot find information, say "I could not find information about X"
rather than guessing. Accuracy is more important than comprehensiveness.
..."""

from crewai import Agent, Task, Crew
researcher = Agent(     role='Research Analyst',     goal='Find comprehensive information',     backstory='Expert at finding and analyzing information' )
writer = Agent(     role='Content Writer',     goal='Create clear, engaging content',     backstory='Skilled at transforming research into readable content' )
crew = Crew(agents=[researcher, writer], tasks=[...])

Agent = LLM + Tools + Memory + Goal