Research Agent Blueprint

You are a research agent. Your job is to answer questions using web search,
content extraction, and fact-checking. Follow this protocol:

1. THOUGHT: Analyze what you need to find out
2. ACTION: Call one or more tools
3. Observe the results
4. Continue the THOUGHT → ACTION cycle until you have a complete answer
5. FINAL_ANSWER: Provide the answer with numbered citations [#1], [#2], etc.

Rules:
- Always cite specific sources. Never make up facts.
- If two sources conflict, note the discrepancy.
- Prefer primary sources over secondary sources.
- For statistical claims, find at least two corroborating sources.
- If you cannot verify a claim, state that it is unverified.

# tools.py
import json
import requests

BRAVE_API_KEY = None
OPENAI_CLIENT = None
sources = []

def set_keys(brave_key, openai_client):
    global BRAVE_API_KEY, OPENAI_CLIENT
    BRAVE_API_KEY = brave_key
    OPENAI_CLIENT = openai_client

def web_search(query: str, count: int = 5):
    headers = {
        "Accept": "application/json",
        "X-Subscription-Token": BRAVE_API_KEY
    }
    resp = requests.get(
        "https://api.search.brave.com/res/v1/web/search",
        params={"q": query, "count": count},
        headers=headers
    )
    data = resp.json()
    results = []
    for r in data.get("web", {}).get("results", []):
        results.append({
            "title": r.get("title"),
            "url": r.get("url"),
            "description": r.get("description")
        })
    return json.dumps(results)

def extract_content(url: str):
    resp = requests.get(url, headers={"User-Agent": "ResearchAgent/1.0"})
    from bs4 import BeautifulSoup
    soup = BeautifulSoup(resp.text, "html.parser")
    for tag in soup(["script", "style", "nav", "footer", "header"]):
        tag.decompose()
    text = soup.get_text(separator="\n", strip=True)
    return text[:4000]

def fact_check(claim: str):
    return web_search(f'"{claim}" fact check')

def cite_source(url: str, title: str, snippet: str):
    global sources
    sources.append({"url": url, "title": title, "snippet": snippet})
    return f"Source #{len(sources)} recorded"

# agent.py
import json
import argparse
import importlib
from openai import OpenAI
import tools as agent_tools

TOOL_SCHEMAS = [
    {
        "type": "function",
        "function": {
            "name": "web_search",
            "description": "Search the web using Brave Search API",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string"},
                    "count": {"type": "integer", "default": 5}
                },
                "required": ["query"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "extract_content",
            "description": "Fetch and extract main text from a URL",
            "parameters": {
                "type": "object",
                "properties": {
                    "url": {"type": "string"}
                },
                "required": ["url"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "fact_check",
            "description": "Search for corroborating evidence for a claim",
            "parameters": {
                "type": "object",
                "properties": {
                    "claim": {"type": "string"}
                },
                "required": ["claim"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "cite_source",
            "description": "Record a source for citation",
            "parameters": {
                "type": "object",
                "properties": {
                    "url": {"type": "string"},
                    "title": {"type": "string"},
                    "snippet": {"type": "string"}
                },
                "required": ["url", "title", "snippet"]
            }
        }
    }
]

SYSTEM_PROMPT = """You are a research agent. Your job is to answer questions using
web search, content extraction, and fact-checking. Follow this protocol:

1. THOUGHT: Analyze what you need to find out
2. ACTION: Call one or more tools
3. Observe the results
4. Continue the THOUGHT → ACTION cycle until you have a complete answer
5. FINAL_ANSWER: Provide the answer with numbered citations [#1], [#2], etc.

Rules:
- Always cite specific sources. Never make up facts.
- If two sources conflict, note the discrepancy.
- Prefer primary sources over secondary sources.
- For statistical claims, find at least two corroborating sources.
- If you cannot verify a claim, state that it is unverified."""

def run_agent(query, config):
    client = OpenAI(api_key=config["openai_api_key"])
    agent_tools.set_keys(config["brave_api_key"], client)
    agent_tools.sources = []

    messages = [
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": query}
    ]

    for i in range(config.get("max_iterations", 10)):
        response = client.chat.completions.create(
            model=config.get("model", "gpt-4o"),
            messages=messages,
            tools=TOOL_SCHEMAS,
            temperature=config.get("temperature", 0.3)
        )

        msg = response.choices[0].message
        messages.append(msg)

        if msg.content and "FINAL_ANSWER:" in msg.content:
            answer = msg.content.split("FINAL_ANSWER:", 1)[1].strip()
            sources_out = agent_tools.sources
            return {"answer": answer, "sources": sources_out}

        if not msg.tool_calls:
            messages.append({
                "role": "user",
                "content": "Continue your research. Use tools or provide FINAL_ANSWER."
            })
            continue

        for tool_call in msg.tool_calls:
            func_name = tool_call.function.name
            func_args = json.loads(tool_call.function.arguments)
            func = getattr(agent_tools, func_name)
            result = func(**func_args)
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": result
            })

    return {"answer": "Agent reached max iterations.", "sources": agent_tools.sources}

if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--query", required=True)
    parser.add_argument("--config", default="config.json")
    args = parser.parse_args()

    with open(args.config) as f:
        config = json.load(f)

    result = run_agent(args.query, config)
    print("ANSWER:", result["answer"])
    print("\nSOURCES:")
    for i, s in enumerate(result["sources"]):
        print(f"  [#{i+1}] {s['title']}")
        print(f"      {s['url']}")