Deep Research com LangGraph: Crie um Assistente de IA para Pesquisar Automaticamente

Para realizar o assistente vamos usar a seguinte arquitetura:

	

		
!uv init deepresearcher
	
	

		
			
		
	
	
Copied

	

		
error: Project is already initialized in `/Users/macm1/Documents/web/portafolio/posts/deepresearcher` (`pyproject.toml` file exists)
	

	

		
!cd deepresearcher && uv sync
	
	

		
			
		
	
	
Copied

	

		
Resolved 88 packages in 9ms
Audited 84 packages in 0.38ms
	

	

		
!cd deepresearcher && source .venv/bin/activate
	
	

		
			
		
	
	
Copied

	

		
!cd deepresearcher && source .venv/bin/activate && uv add "alive-progress>=3.3.0" "dotenv>=0.9.9" "grandalf>=0.8" "ipykernel>=6.30.1" "langchain>=0.3.27" "langchain-anthropic>=0.3.21" "langchain-community>=0.3.29" "langchain-mcp-adapters>=0.1.11" "langchain-openai>=0.3.33" "langgraph>=0.6.7" "rich>=14.1.0" "tavily-python>=0.7.12"
	
	

		
			
		
	
	
Copied

	

		
Resolved 88 packages in 0.59ms
Audited 84 packages in 0.01ms
	

	

		
from pathlib import Path
 
def get_current_dir() -> Path:
    """Get the current directory of the module.
 
    This function is compatible with Jupyter notebooks and regular Python scripts.
 
    Returns:
        Path object representing the current directory
    """
    try:
        return Path(__file__).resolve().parent
    except NameError: # __file__ is not defined
        return Path.cwd()
	
	

		
			
		
	
	
Copied

	

		
from datetime import datetime
 
def get_today_str() -> str:
    """Get current date in a human-readable format."""
    return datetime.now().strftime("%a %b %-d, %Y")
	
	

		
			
		
	
	
Copied

	

		
from rich.console import Console
from rich.panel import Panel
from rich.text import Text
import json
import ast
 
console = Console()
 
def format_tool_outputs(tool_outputs_list: list) -> str:
    """Format a list of ToolMessage objects into a readable string"""
    formatted_parts = []
    
    for i, output in enumerate(tool_outputs_list, 1):
        # Handle ToolMessage objects that have been converted to strings
        if isinstance(output, dict):
            formatted_parts.append(f"
  Tool Output {i}:")
            formatted_parts.append(f"    Name: {output.get('name', 'N/A')}")
            formatted_parts.append(f"    Tool Call ID: {output.get('tool_call_id', 'N/A')}")
            
            # Format the content (which contains the actual output)
            content = output.get('content', 'N/A')
            if isinstance(content, str):
                # Truncate very long outputs
                if len(content) > 500:
                    content_preview = content[:500] + f"... ({len(content)} chars total)"
                else:
                    content_preview = content
                formatted_parts.append(f"    Content:")
                # Indent each line of content
                for line in content_preview.split('
'):
                    formatted_parts.append(f"      {line}")
            else:
                formatted_parts.append(f"    Content: {content}")
        else:
            formatted_parts.append(f"
  Tool Output {i}: {output}")
    
    return "
".join(formatted_parts)
 
def format_string_with_structures(content: str) -> str:
    """
    Detect and format structured data (lists, dicts) within a string.
    Handles cases like 'Tool calls: [...]' and 'Tool outputs: [...]' by parsing and formatting the structure.
    """
    # Check if the string contains 'Tool outputs:' followed by a list
    if 'Tool outputs:' in content:
        try:
            # Find the position where the tool outputs list starts
            tool_outputs_index = content.index('Tool outputs:')
            prefix = content[:tool_outputs_index + len('Tool outputs:')]
            
            # Extract the part that should be a list
            potential_list = content[tool_outputs_index + len('Tool outputs:'):].strip()
            
            # Try to parse it as a Python literal (list/dict)
            parsed_data = ast.literal_eval(potential_list)
            
            # If it's a list of tool outputs, format them nicely
            if isinstance(parsed_data, list):
                formatted_parts = [prefix + "
"]
                formatted_parts.append(format_tool_outputs(parsed_data))
                return "
".join(formatted_parts)
        except (ValueError, SyntaxError):
            # If parsing fails, continue to next check
            pass
    
    # Check if the string contains 'Tool calls:' followed by a list
    if 'Tool calls:' in content:
        try:
            # Find the position where the tool calls list starts
            tool_calls_index = content.index('Tool calls:')
            prefix = content[:tool_calls_index + len('Tool calls:')]
            
            # Extract the part that should be a list
            potential_list = content[tool_calls_index + len('Tool calls:'):].strip()
            
            # Try to parse it as a Python literal (list/dict)
            parsed_data = ast.literal_eval(potential_list)
            
            # If it's a list of tool calls, format them nicely
            if isinstance(parsed_data, list):
                formatted_parts = [prefix + "
"]
                for i, tool_call in enumerate(parsed_data, 1):
                    if isinstance(tool_call, dict):
                        formatted_parts.append(f"
  Tool Call {i}:")
                        formatted_parts.append(f"    Name: {tool_call.get('name', 'N/A')}")
                        formatted_parts.append(f"    ID: {tool_call.get('id', 'N/A')}")
                        formatted_parts.append(f"    Type: {tool_call.get('type', 'N/A')}")
                        if 'args' in tool_call:
                            formatted_parts.append(f"    Args:")
                            formatted_parts.append(f"       {json.dumps(tool_call['args'], indent=7, ensure_ascii=False)}")
                return "
".join(formatted_parts)
        except (ValueError, SyntaxError):
            # If parsing fails, return the original content
            pass
    
    # Try to detect if the entire content is a JSON/dict/list
    try:
        # Try JSON first
        parsed = json.loads(content)
        return json.dumps(parsed, indent=2, ensure_ascii=False)
    except (json.JSONDecodeError, TypeError):
        try:
            # Try Python literal (ast.literal_eval)
            parsed = ast.literal_eval(content)
            return json.dumps(parsed, indent=2, ensure_ascii=False)
        except (ValueError, SyntaxError):
            # If all parsing attempts fail, return original content
            return content
 
def format_message_content(message):
    """Convert message content to displayable string"""
    parts = []
    tool_calls_processed = False
 
    # Handle ToolCall objects (special case - they don't have 'content')
    if isinstance(message, dict) and 'args' in message and 'name' in message:
        # This is a ToolCall dictionary
        parts.append(f"Tool Call Name: {message.get('name', 'N/A')}")
        parts.append(f"ID: {message.get('id', 'N/A')}")
        
        # Format the args (which should be the tool calls list)
        args = message.get('args', [])
        if isinstance(args, list):
            for i, tool_call in enumerate(args, 1):
                if isinstance(tool_call, dict):
                    parts.append(f"
  Tool Call {i}:")
                    parts.append(f"    Name: {tool_call.get('name', 'N/A')}")
                    parts.append(f"    ID: {tool_call.get('id', 'N/A')}")
                    parts.append(f"    Type: {tool_call.get('type', 'N/A')}")
                    if 'args' in tool_call:
                        parts.append(f"    Args:")
                        parts.append(f"       {json.dumps(tool_call['args'], indent=7, ensure_ascii=False)}")
        return "
".join(parts)
    
    # Check if message has 'content' attribute
    if not hasattr(message, 'content'):
        # If it's a dict-like object, try to access it as a dict
        if hasattr(message, '__getitem__'):
            try:
                content = message['content'] if 'content' in message else str(message)
                parts.append(content)
                return "
".join(parts)
            except (KeyError, TypeError):
                parts.append(str(message))
                return "
".join(parts)
        else:
            parts.append(str(message))
            return "
".join(parts)
    
    # Handle main content (normal messages with 'content' attribute)
    if isinstance(message.content, str):
        # Try to detect and format structured data within the string
        formatted_content = format_string_with_structures(message.content)
        parts.append(formatted_content)
    elif isinstance(message.content, list):
        # Handle complex content like tool calls (Anthropic format)
        for item in message.content:
            if item.get('type') == 'text':
                parts.append(item['text'])
            elif item.get('type') == 'tool_use':
                parts.append(f"
🔧 Tool Call: {item['name']}")
                parts.append(f"   Args: {str(json.dumps(item['input'], indent=7, ensure_ascii=False))}")
                parts.append(f"   ID: {item.get('id', 'N/A')}")
                tool_calls_processed = True
    else:
        parts.append(str(message.content))
    
    # Handle tool calls attached to the message (OpenAI format) - only if not already processed
    if not tool_calls_processed and hasattr(message, 'tool_calls') and message.tool_calls:
        for tool_call in message.tool_calls:
            parts.append(f"
🔧 Tool Call: {tool_call['name']}")
            parts.append(f"   Args: {json.dumps(tool_call['args'], indent=2)}")
            parts.append(f"   ID: {tool_call['id']}")
    
    return "
".join(parts)
 
def format_messages(messages, title: str = "", border_style: str = "white", msg_subtype: str = ""):
    """Format and display a list of messages with Rich formatting
    
    Args:
        messages: List of messages to format
        title: Title of the panel
        border_style: Border style of the panel
        msg_subtype: Subtype of the message
    """
    # Check if messages is a list
    if isinstance(messages, list):
        for m in messages:
            # Handle different message types
            if isinstance(m, dict):
                # Check if it's a ToolCall dict
                if 'args' in m and 'name' in m:
                    msg_type = 'ToolCall'
                else:
                    msg_type = 'Dict'
            else:
                msg_type = m.__class__.__name__.replace('Message', '')
            
            content = format_message_content(m)
 
            if msg_type == 'Human':
                if msg_subtype == 'RealHumanMessage':
                    if title == "":
                        title = "🧑 Real Human Message"
                    else:
                        title = f"🧑 {title}"
                    console.print(Panel(content, title=title, border_style="#201ADB")) # Blue
                else:
                    if title == "":
                        title = "🧑 Simulated Human Message"
                    else:
                        title = f"🧑 {title}"
                    console.print(Panel(content, title=title, border_style="#1A64DB")) # Blue
            elif msg_type == 'AI':
                if title == "":
                    title = "🤖 Assistant"
                else:
                    title = f"🤖 {title}"
                console.print(Panel(content, title=title, border_style="#24FA00")) # Green
            elif msg_type == 'ClarifyWithUser':
                if title == "":
                    title = "🤖 Clarify With User"
                else:
                    title = f"🤖 {title}"
                console.print(Panel(content, title=title, border_style="#37DB1A")) # Green
            elif msg_type == 'ResearchQuestion':
                if title == "":
                    title = "🤖 Research brief generated"
                else:
                    title = f"🤖 {title}"
                console.print(Panel(content, title=title, border_style="#37DB1A")) # Green
            elif msg_type == 'Tool':
                if title == "":
                    title = "🔧 Tool Output"
                else:
                    title = f"🔧 {title}"
                console.print(Panel(content, title=title, border_style="yellow"))
            elif msg_type == 'ToolCall':
                if title == "":
                    title = "🔧 Tool Calls"
                else:
                    title = f"🔧 {title}"
                console.print(Panel(content, title=title, border_style="magenta"))
            elif msg_type == 'Use tools':
                if title == "":
                    title = "🔧 Tool Output"
                else:
                    title = f"🔧 {title}"
                console.print(Panel(content, title=title, border_style="yellow"))
            elif msg_type == 'System':
                if title == "":
                    title = "🔧 System Message"
                else:
                    title = f"🔧 {title}"
                console.print(Panel(content, title=title, border_style="red"))
            else:
                print(f"msg_type: {msg_type}")
                if title == "":
                    title = f"📝 {msg_type}"
                else:
                    title = f"📝 {title}"
                console.print(Panel(content, title=title, border_style="white"))
    elif isinstance(messages, str):
        console.print(Panel(messages, title=title, border_style=border_style))
    else:
        print(f"messages type: {type(messages)}")
	
	

		
			
		
	
	
Copied

	

		
clarify_with_user_instructions="""
Estas são as mensagens trocadas até agora com o usuário que solicitou o relatório:
<Messages>
{messages}
</Messages>
 
A data de hoje é {date}.
 
Avalie se você precisa fazer alguma pergunta esclarecedora ou se o usuário já forneceu informações suficientes para iniciar a investigação.
IMPORTANTE: Se no histórico de mensagens você perceber que já fez uma pergunta esclarecedora, na maioria das vezes não será necessário fazer outra. Só faça outra pergunta se for ABSOLUTAMENTE NECESSÁRIO.
 
Se houver acrônimos, abreviações ou termos desconhecidos, peça ao usuário para esclarecê-los.
Se precisar fazer uma pergunta, siga estas diretrizes:
- Seja conciso ao coletar todas as informações necessárias.
- Certifique-se de coletar todas as informações necessárias para realizar a tarefa de investigação de forma concisa e bem estruturada.
 - Use marcadores ou listas numeradas, se necessário, para maior clareza. Certifique-se de usar o formato Markdown e de que ele será exibido corretamente se a string de saída for passada para um renderizador Markdown.
 - Não solicite informações desnecessárias ou informações que o usuário já tenha fornecido. Se você perceber que o usuário já forneceu as informações, não as solicite novamente.
 
Responda em formato JSON válido com estas chaves exatas:
“need_clarification”: boolean,
‘question’: “<pergunta para solicitar ao usuário que esclareça o escopo do relatório>”,
“verification”: “<mensagem de verificação de que iniciaremos a investigação>”
 
Se precisar fazer uma pergunta esclarecedora, retorne:
“need_clarification”: true,
‘question’: “<sua pergunta esclarecedora>”,
“verification”: “”
 
Se você não precisar fazer uma pergunta esclarecedora, retorne:
“need_clarification”: false,
‘question’: “”,
“verification”: “<Mensagem de confirmação de que a investigação será iniciada com base nas informações fornecidas.>”
 
Para a mensagem de verificação quando não for necessário esclarecimento:
- Confirme que você tem informações suficientes para continuar.
 - Resuma brevemente os aspectos principais do que você entendeu da solicitação.
 - Confirme que o processo de investigação será iniciado agora.
 - Mantenha a mensagem concisa e profissional.
 
Responda sempre no idioma em que o usuário fez a pergunta. Em caso de dúvida, responda em português.
"""
	
	

		
			
		
	
	
Copied

	

		
transform_messages_into_research_topic_prompt = """Você receberá um conjunto de mensagens que foram trocadas até agora entre o usuário e você. 
Sua tarefa consiste em traduzir essas mensagens em uma pergunta de pesquisa mais detalhada e específica que será usada para orientar a pesquisa.
 
As mensagens trocadas até agora entre você e o usuário são:
<Messages>
{messages}
</Messages>
 
A data de hoje é {date}.
 
Você retornará uma única pergunta de pesquisa que será usada para orientar a pesquisa.
 
Diretrizes:
1. Maximize a especificidade e os detalhes.
- Inclua todas as preferências conhecidas do usuário e liste explicitamente os atributos ou dimensões-chave a serem considerados.
- É importante que todos os detalhes do usuário sejam incluídos nas instruções.
 
2. Trate com cuidado as dimensões não especificadas
- Quando a qualidade da pesquisa exigir que dimensões adicionais não especificadas pelo usuário sejam consideradas, reconheça-as como considerações em aberto, em vez de preferências presumidas.
- Exemplo: em vez de assumir “opções econômicas”, diga “considere todas as faixas de preço, a menos que sejam especificadas restrições de custo”.
- Mencione apenas as dimensões que são realmente necessárias para uma pesquisa exaustiva nessa área.
 
3. Evite suposições injustificadas
- Nunca invente preferências, restrições ou requisitos específicos do usuário que não tenham sido indicados.
- Se o usuário não forneceu um detalhe específico, indique explicitamente essa falta de especificação.
- Oriente o pesquisador a tratar os aspectos não especificados como flexíveis, em vez de fazer suposições.
 
4. Distinga entre o escopo da pesquisa e as preferências do usuário
- Escopo da pesquisa: quais tópicos/dimensões devem ser pesquisados (pode ser mais amplo do que as menções explícitas do usuário)
- Preferências do usuário: restrições, requisitos ou preferências específicas (você só deve incluir o que o usuário indicou)
- Exemplo: “Investigar os fatores que influenciam a qualidade do café (incluindo a origem dos grãos, os métodos de torrefação e as técnicas de preparação) nas cafeterias de Madri, com foco principalmente no sabor, conforme especificado pelo usuário”.
 
5. Use a primeira pessoa
- Redija a solicitação da perspectiva do usuário.
 
6. Fontes
- Se fontes específicas devem ter prioridade, especifique-as na pergunta de pesquisa.
- Para pesquisas sobre produtos e viagens, é preferível criar links diretos para sites oficiais ou primários (por exemplo, sites oficiais de marcas, páginas de fabricantes ou plataformas de comércio eletrônico renomadas, como a Amazon, para opiniões de usuários), em vez de sites agregadores ou blogs com muito SEO.
- Para consultas acadêmicas ou científicas, é preferível criar um link direto para o artigo original ou a publicação oficial em uma revista, em vez de artigos de pesquisas ou resumos secundários.
- No caso de pessoas, tente criar um link direto para o perfil do LinkedIn, site pessoal ou perfil do GitHub, se houver.
- Se a consulta estiver em um idioma específico, dê prioridade às fontes publicadas nesse idioma.
 
Responda sempre no idioma em que o usuário lhe perguntou. Em caso de dúvida, responda em português.
"""
	
	

		
			
		
	
	
Copied

	

		
import operator
from typing_extensions import Optional, Annotated, Sequence
 
from langchain_core.messages import BaseMessage
from langgraph.graph import MessagesState
from langgraph.graph.message import add_messages
 
class AgentInputState(MessagesState):
    """Input state for the full agent - only contains messages from user input."""
    pass
 
class AgentState(MessagesState):
    """
    Main state for the full multi-agent research system.
 
    Extends MessagesState with additional fields for research coordination.
    Note: Some fields are duplicated across different state classes for proper
    state management between subgraphs and the main workflow.
    """
 
    # Research brief generated from user conversation history
    research_brief: Optional[str]
    # Messages exchanged with the supervisor agent for coordination
    supervisor_messages: Annotated[Sequence[BaseMessage], add_messages]
    # Raw unprocessed research notes collected during the research phase
    raw_notes: Annotated[list[str], operator.add] = []
    # Processed and structured notes ready for report generation
    notes: Annotated[list[str], operator.add] = []
    # Final formatted research report
    final_report: str
	
	

		
			
		
	
	
Copied

estado = {
"messages": ["Olá, como você está?"],
"research_brief": "Investigar os fatores que influenciam a qualidade do café",
"supervisor_messages": [],
"raw_notes": [],
"notes": [],
"final_report": ""
}

agent.invoke(state)

	

		
from pydantic import BaseModel, Field
 
class ClarifyWithUser(BaseModel):
    """Schema for user clarification decision and questions."""
 
    need_clarification: bool = Field(
        description="Whether the user needs to be asked a clarifying question.",
    )
    question: str = Field(
        description="A question to ask the user to clarify the report scope",
    )
    verification: str = Field(
        description="Verify message that we will start research after the user has provided the necessary information.",
    )
 
class ResearchQuestion(BaseModel):
    """Schema for structured research brief generation."""
 
    research_brief: str = Field(
        description="A research question that will be used to guide the research.",
    )
	
	

		
			
		
	
	
Copied

	

		
from langchain.chat_models import init_chat_model
import os
import dotenv
 
dotenv.load_dotenv()
 
SCOPE_MODEL_NAME = "gpt-4.1"
SCOPE_MODEL_PROVIDER = "openai"
SCOPE_MODEL_BASE_URL = "https://api.openai.com/v1"
SCOPE_MODEL_TEMPERATURE = 0.0
SCOPE_MODEL_PROVIDER_API_KEY = os.getenv("OPENAI_API_KEY")
 
scope_model = init_chat_model(
    model=SCOPE_MODEL_NAME,
    model_provider=SCOPE_MODEL_PROVIDER,
    api_key=SCOPE_MODEL_PROVIDER_API_KEY,
    base_url=SCOPE_MODEL_BASE_URL,
    temperature=SCOPE_MODEL_TEMPERATURE
)
	
	

		
			
		
	
	
Copied

	

		
from typing_extensions import Literal
from alive_progress import alive_bar
import traceback
import sys
 
from langchain_core.messages import HumanMessage, AIMessage, SystemMessage, get_buffer_string
from langgraph.graph import START, END
from langgraph.types import Command
 
def clarify_with_user(state: AgentState) -> Command[Literal["write_research_brief", "__end__"]]:
    """
    Determine if the user's request contains sufficient information to proceed with research.
    
    Uses structured output to make deterministic decisions and avoid hallucination.
    Routes to either research brief generation or ends with a clarification question.
    """
 
    try:
        print("⏳ Scope agent:")
        format_messages([state.get("messages", [])[-1]], title="Real Human Message", msg_subtype='RealHumanMessage')
 
        # Set up structured output model
        structured_output_model = scope_model.with_structured_output(ClarifyWithUser)
 
        # Invoke the model with clarification instructions
        with alive_bar(monitor=False, stats=False, title="", spinner='dots_waves', bar='blocks') as bar:
            response = structured_output_model.invoke([
                HumanMessage(content=clarify_with_user_instructions.format(
                    messages=get_buffer_string(messages=state["messages"]),
                    date=get_today_str()
                ))
            ])
            bar()
        
        # Format and display the research messages
        format_messages([response], title="Scope Assistant - need clarification?")
        
        # Route based on clarification need
        if response.need_clarification:
            # Create a System message to show the decision
            routing_message = SystemMessage(
                content="Necesita aclaración por parte del usuario. Enviando pregunta aclaratoria..."
            )
            format_messages([routing_message], title="Scope System Message")
            return Command(
                goto=END,
                update={"messages": [AIMessage(content=response.question)]}
            )
        else:
            # Create a System message to show the decision
            routing_message = SystemMessage(
                content="No necesita aclaración por parte del usuario. Enviando mensaje de verificación..."
            )
            format_messages([routing_message], title="Scope System Message")
            return Command(
                goto="write_research_brief",
                update={"messages": [AIMessage(content=response.verification)]}
            )
    
    except Exception as e:
        # Get the traceback information
        exc_type, exc_obj, exc_tb = sys.exc_info()
        line_number = exc_tb.tb_lineno
        
        # Print detailed error information
        print(f"
❌ Error in clarify_with_user function:")
        print(f"   Line number: {line_number}")
        print(f"   Error type: {type(e).__name__}")
        print(f"   Error message: {str(e)}")
        print(f"
   Full traceback:")
        traceback.print_exc()
        
        # Re-raise the exception to let the caller handle it
        raise
	
	

		
			
		
	
	
Copied

	

		
def write_research_brief(state: AgentState):
    """
    Transform the conversation history into a comprehensive research brief.
    
    Uses structured output to ensure the brief follows the required format
    and contains all necessary details for effective research.
    """
    
    try:
        # Set up structured output model
        structured_output_model = scope_model.with_structured_output(ResearchQuestion)
 
        print("⏳ Scope agent - Write research brief:")
        format_messages([state.get("messages", [])[-1]], title="Scope Assistant - Write research brief")
        
        # Generate research brief from conversation history
        with alive_bar(monitor=False, stats=False, title="", spinner='dots_waves', bar='blocks') as bar:
            response = structured_output_model.invoke([
                HumanMessage(content=transform_messages_into_research_topic_prompt.format(
                    messages=get_buffer_string(state.get("messages", [])),
                    date=get_today_str()
                ))
            ])
            bar()
        
        # Format and display the research brief
        format_messages([response], title="Scope Assistant - Research brief generated")
        
        # Update state with generated research brief and pass it to the supervisor
        return {
            "research_brief": response.research_brief,
            "supervisor_messages": [HumanMessage(content=f"{response.research_brief}.")]
        }
    
    except Exception as e:
        # Get the traceback information
        exc_type, exc_obj, exc_tb = sys.exc_info()
        line_number = exc_tb.tb_lineno
        
        # Print detailed error information
        print(f"
❌ Error in write_research_brief function:")
        print(f"   Line number: {line_number}")
        print(f"   Error type: {type(e).__name__}")
        print(f"   Error message: {str(e)}")
        print(f"
   Full traceback:")
        traceback.print_exc()
        
        # Re-raise the exception to let the caller handle it
        raise
	
	

		
			
		
	
	
Copied

	

		
from langgraph.graph import StateGraph
 
# Build the scoping workflow
scope_graph_builder = StateGraph(AgentState, input_schema=AgentInputState)
	
	

		
			
		
	
	
Copied

	

		
# Add workflow nodes
scope_graph_builder.add_node("clarify_with_user", clarify_with_user)
scope_graph_builder.add_node("write_research_brief", write_research_brief)
	
	

		
			
		
	
	
Copied

	

		
<langgraph.graph.state.StateGraph at 0x1117ff0e0>
	

	

		
from langgraph.graph import START, END
 
# Add workflow edges
scope_graph_builder.add_edge(START, "clarify_with_user")
scope_graph_builder.add_edge("write_research_brief", END)
	
	

		
			
		
	
	
Copied

	

		
<langgraph.graph.state.StateGraph at 0x1117ff0e0>
	

	

		
from langgraph.checkpoint.memory import InMemorySaver
from IPython.display import Image, display
 
checkpointer = InMemorySaver()
scope_agent = scope_graph_builder.compile(checkpointer=checkpointer)
 
# Visualize the workflow
display(Image(scope_agent.get_graph(xray=True).draw_mermaid_png()))
	
	

		
			
		
	
	
Copied

	

		
<IPython.core.display.Image object>
	

	

		
thread = {"configurable": {"thread_id": "1"}}
user_message = "Quero pesquisar os melhores cafés de Madrid.."
 
result = await scope_agent.ainvoke({"messages": [HumanMessage(content=f"{user_message}.")]}, config=thread)
	
	

		
			
		
	
	
Copied

	

		
⏳ Scope agent:
	

	

		
╭───────────────────────────────────────────── 🧑 Real Human Message ─────────────────────────────────────────────╮
│ Quero pesquisar os melhores cafés de Madrid...                                                                  │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
	

	

		
|▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉| in 1.2s
	

	

		
╭─────────────────────────────────── 🤖 Scope Assistant - need clarification? ────────────────────────────────────╮
│ need_clarification=True question='Você está procurando cafés para trabalhar, para apreciar cafés especiais, ou  │
│ apenas os mais populares entre turistas e locais? Há algum bairro específico de Madrid que você prefere?'       │
│ verification=''                                                                                                 │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
	

	

		
╭──────────────────────────────────────────── 🔧 Scope System Message ────────────────────────────────────────────╮
│ Necesita aclaración por parte del usuario. Enviando pregunta aclaratoria...                                     │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
	

	

		
user_message = "Examine a qualidade do café para avaliar as melhores cafeterias de Madri.."
 
result = await scope_agent.ainvoke({"messages": [HumanMessage(content=f"{user_message}.")]}, config=thread)
	
	

		
			
		
	
	
Copied

	

		
⏳ Scope agent:
	

	

		
╭───────────────────────────────────────────── 🧑 Real Human Message ─────────────────────────────────────────────╮
│ Examine a qualidade do café para avaliar as melhores cafeterias de Madri...                                     │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
	

	

		
|▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉| in 1.3s
	

	

		
╭─────────────────────────────────── 🤖 Scope Assistant - need clarification? ────────────────────────────────────╮
│ need_clarification=False question='' verification='Você forneceu informações suficientes para iniciar a         │
│ pesquisa. Entendi que deseja um relatório sobre as melhores cafeterias de Madri, com foco na qualidade do café  │
│ servido. Iniciarei agora a investigação considerando esse critério principal.'                                  │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
	

	

		
╭──────────────────────────────────────────── 🔧 Scope System Message ────────────────────────────────────────────╮
│ No necesita aclaración por parte del usuario. Enviando mensaje de verificación...                               │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
	

	

		
⏳ Scope agent - Write research brief:
	

	

		
╭─────────────────────────────────── 🤖 Scope Assistant - Write research brief ───────────────────────────────────╮
│ Você forneceu informações suficientes para iniciar a pesquisa. Entendi que deseja um relatório sobre as         │
│ melhores cafeterias de Madri, com foco na qualidade do café servido. Iniciarei agora a investigação             │
│ considerando esse critério principal.                                                                           │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
	

	

		
|▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉| in 4.2s
	

	

		
╭───────────────────────────────── 🤖 Scope Assistant - Research brief generated ─────────────────────────────────╮
│ research_brief='Quero identificar as melhores cafeterias de Madri avaliando principalmente a qualidade do café  │
│ servido. Para isso, desejo que a pesquisa considere critérios como a origem e seleção dos grãos, métodos de     │
│ torra, técnicas de preparo, frescor do café, sabor e aroma, bem como eventuais prêmios ou reconhecimentos       │
│ relacionados à qualidade do café. Não especifiquei bairros, estilos de ambiente, faixas de preço ou outros      │
│ serviços oferecidos, portanto, esses aspectos devem ser tratados como abertos e flexíveis. Priorize fontes      │
│ oficiais das cafeterias, avaliações de especialistas em café, rankings de publicações reconhecidas no setor e   │
│ opiniões de consumidores em plataformas confiáveis, preferencialmente em português ou espanhol.'                │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
	

Se lembrarmos de como seria a arquitetura do deep researcher, vemos que há um Research supervisor que se encarrega de atribuir pesquisas a diferentes Researchers

	

		
research_agent_prompt = """Você é um assistente de pesquisa que realiza uma pesquisa sobre o tema introduzido pelo usuário. Para contextualizar, hoje é {date}.
 
<Task>
Seu trabalho consiste em usar ferramentas para coletar informações sobre o tema introduzido pelo usuário.
Você pode usar qualquer uma das ferramentas fornecidas para encontrar recursos que o ajudem a responder à pergunta de pesquisa. Você pode usar essas ferramentas em série ou em paralelo, sua pesquisa é realizada em um loop de chamada de ferramentas.
</Task>
 
<Available Tools>
Você tem acesso a duas ferramentas principais:
1. **tavily_search**: para realizar pesquisas na web com o objetivo de coletar informações.
2. **think_tool**: para reflexão e planejamento estratégico durante a pesquisa.
 
**IMPORTANTE: use a ferramenta think_tool após cada pesquisa para refletir sobre os resultados e planejar os próximos passos**.
**CRÍTICO: você deve sempre fornecer o parâmetro “reflection” com conteúdo detalhado ao chamar o think_tool. Nunca chame essa ferramenta sem argumentos**.
</Available Tools>
 
<Instructions>
Pense como um pesquisador humano com tempo limitado. Siga estas etapas:
 
1. **Leia a pergunta com atenção**: quais informações específicas o usuário precisa?
2. **Comece com pesquisas mais amplas**: use primeiro consultas amplas e exaustivas.
3. **Após cada pesquisa, faça uma pausa e avalie**: tenho o suficiente para responder? O que me falta?
4. **Faça pesquisas mais específicas à medida que coleta informações**: preencha as lacunas.
5. **Pare quando puder responder com segurança**: não continue buscando a perfeição.
</Instructions>
 
<Hard Limits>
**Orçamentos de chamadas para ferramentas** (evite pesquisas excessivas):
- **Consultas simples**: use no máximo 2-3 chamadas para ferramentas de pesquisa.
- **Consultas complexas**: use no máximo 5 chamadas para ferramentas de pesquisa
- **Pare sempre**: após 5 chamadas para ferramentas de pesquisa, se você não conseguir encontrar as fontes adequadas
 
**Pare imediatamente quando**:
- Você puder responder à pergunta do usuário de forma exaustiva
- Você tiver mais de 3 exemplos/fontes relevantes para a pergunta
- Suas duas últimas pesquisas tenham retornado informações semelhantes
</Hard Limits>
 
<Show Your Thinking>
Após cada chamada à ferramenta de pesquisa, use think_tool para analisar os resultados:
- Que informações importantes eu encontrei?
- O que está faltando?
- Tenho o suficiente para responder à pergunta de forma exaustiva?
- Devo continuar pesquisando ou dar minha resposta?
</Show Your Thinking>
"""
	
	

		
			
		
	
	
Copied

	

		
summarize_webpage_prompt = """Sua tarefa consiste em resumir o conteúdo bruto de uma página da web obtida por meio de uma pesquisa na Internet. Seu objetivo é criar um resumo que preserve as informações mais importantes da página da web original. Esse resumo será usado por um agente de pesquisa posterior, portanto, é fundamental manter os detalhes principais sem perder informações essenciais.
 
Este é o conteúdo não processado da página da web:
 
<webpage_content>
{webpage_content}
</webpage_content>
 
Siga estas diretrizes para criar seu resumo:
 
1. Identifique e preserve o tema principal ou o objetivo da página da web.
2. Preserve os dados, estatísticas e pontos-chave que são fundamentais para a mensagem do conteúdo.
3. Preserve citações importantes de fontes ou especialistas confiáveis.
4. Mantenha a ordem cronológica dos eventos se o conteúdo for sensível ao tempo ou histórico.
5. Preserve listas ou instruções passo a passo, se houver.
6. Inclua datas, nomes e locais relevantes que sejam cruciais para a compreensão do conteúdo.
7. Resuma explicações longas, mantendo intacta a mensagem principal.
 
Quando se trata de diferentes tipos de conteúdo:
 
- Para artigos de notícias: concentre-se em quem, o quê, quando, onde, por que e como.
- Para conteúdo científico: mantenha a metodologia, os resultados e as conclusões.
- Para artigos de opinião: mantenha os argumentos principais e os pontos de apoio.
- Para páginas de produtos: mantenha as características principais, as especificações e os pontos de venda exclusivos.
 
Seu resumo deve ser significativamente mais curto que o conteúdo original, mas completo o suficiente para constituir uma fonte de informação por si só. Tente que ele tenha entre 25% e 30% do comprimento original, a menos que o conteúdo já seja conciso.
 
Apresente seu resumo no seguinte formato:
 
```
{{
   “summary”: “Seu resumo aqui, estruturado com parágrafos ou marcadores adequados, conforme necessário”,
   “key_excerpts”: “Primeira citação ou trecho importante, Segunda citação ou trecho importante, Terceira citação ou trecho importante, ...Adicione mais trechos conforme necessário, até um máximo de 5”
}}
```
 
Aqui estão dois exemplos de bons resumos:
 
Exemplo 1 (para um artigo de notícias):
```json
{{
   “summary”: "Em 15 de julho de 2023, a NASA lançou com sucesso a missão Artemis II do Centro Espacial Kennedy. Esta é a primeira missão tripulada à Lua desde a Apollo 17 em 1972. A tripulação de quatro pessoas, liderada pela comandante Jane Smith, orbitará a Lua por 10 dias antes de retornar à Terra. Esta missão é um passo crucial nos planos da NASA para estabelecer uma presença humana permanente na Lua até 2030.”,
   “key_excerpts”: “A Artemis II representa uma nova era na exploração espacial, disse o administrador da NASA, John Doe. A missão testará sistemas críticos para futuras estadias de longa duração na Lua, explicou a engenheira-chefe Sarah Johnson. Não vamos apenas voltar à Lua, vamos avançar em direção à Lua, declarou a comandante Jane Smith durante a coletiva de imprensa antes do lançamento."
}}
```
 
Exemplo 2 (para um artigo científico):
```json
{{
   “summary”: "Um novo estudo publicado na Nature Climate Change revela que o nível do mar está subindo mais rápido do que se pensava. Os pesquisadores analisaram dados de satélite de 1993 a 2022 e descobriram que a taxa de aumento do nível do mar acelerou em 0,08 mm/ano² nas últimas três décadas. Essa aceleração é atribuída principalmente ao derretimento das calotas polares da Groenlândia e da Antártida. O estudo prevê que, se as tendências atuais continuarem, o nível global do mar poderá subir até 2 metros até 2100, o que representaria um risco significativo para as comunidades costeiras em todo o mundo.
   “key_excerpts”: “Nossas descobertas indicam uma clara aceleração no aumento do nível do mar, o que tem implicações importantes para o planejamento costeiro e as estratégias de adaptação”, afirmou a autora principal, Dra. Emily Brown. A velocidade do derretimento das camadas de gelo da Groenlândia e da Antártida triplicou desde a década de 1990, de acordo com o estudo. Sem uma redução imediata e substancial das emissões de gases de efeito estufa, enfrentaremos um aumento potencialmente catastrófico do nível do mar no final deste século, alertou o coautor, o professor Michael Green.  
}}
```
 
Lembre-se de que seu objetivo é criar um resumo que possa ser facilmente compreendido e utilizado por um agente de pesquisa posterior, ao mesmo tempo em que preserva as informações mais importantes da página da web original.
 
A data de hoje é {date}.
"""
	
	

		
			
		
	
	
Copied

	

		
compress_research_system_prompt = """Você é um assistente de pesquisa que investigou um tema utilizando diversas ferramentas e pesquisas na Internet. Seu trabalho agora consiste em limpar os resultados, conservando todas as declarações e informações relevantes coletadas pelo pesquisador. Para contextualizar, hoje é {date}.
 
<Task>
Você deve limpar as informações coletadas das ferramentas e pesquisas na Internet nas mensagens existentes.
Todas as informações relevantes devem ser repetidas e reescritas textualmente, mas em um formato mais limpo.
O objetivo desta etapa é simplesmente eliminar qualquer informação obviamente irrelevante ou duplicada.
Por exemplo, se três fontes dizem “X”, você poderia dizer “Essas três fontes afirmam X”.
Apenas esses resultados completos e limpos serão devolvidos ao usuário, por isso é essencial que você não perca nenhuma informação das mensagens não processadas.
</Task>
 
<Tool Call Filtering>
**IMPORTANTE**: Ao processar as mensagens de pesquisa, concentre-se apenas no conteúdo substantivo da pesquisa:
- **Incluir**: Todos os resultados do tavily_search e as descobertas da pesquisa na web
- **Excluir**: as chamadas e respostas do think_tool, pois são reflexões internas do agente para a tomada de decisões e não devem ser incluídas no relatório final da investigação
- **Concentre-se em**: as informações reais coletadas de fontes externas, não no processo de raciocínio interno do agente.
 
As chamadas para o think_tool contêm reflexões estratégicas e notas sobre a tomada de decisões que são internas ao processo de pesquisa, mas não contêm informações factuais que devam ser mantidas no relatório final.
</Tool Call Filtering>
 
<Guidelines>
1. Os resultados devem ser exaustivos e incluir TODAS as informações e fontes que o investigador tenha coletado a partir das chamadas para ferramentas e pesquisas na web. Espera-se que você repita as informações-chave textualmente.
2. Este relatório pode ter a extensão necessária para incluir TODAS as informações que o investigador tenha coletado.
3. Em seu relatório, você deve incluir citações em linha para cada fonte que o investigador tenha encontrado.
4. Você deve incluir uma seção “Fontes” no final do relatório, listando todas as fontes encontradas pelo pesquisador com as citações correspondentes, referenciadas em relação às afirmações do relatório.
5. Certifique-se de incluir TODAS as fontes coletadas pelo pesquisador no relatório e como elas foram usadas para responder à pergunta.
6. É muito importante não perder nenhuma fonte. Mais adiante, um LLM será usado para mesclar este relatório com outros, por isso é essencial ter todas as fontes disponíveis.
</Guidelines>
 
<Output Format>
O relatório deve ser estruturado da seguinte forma:
**Lista de consultas e chamadas a ferramentas realizadas**
**Resultados completos**
**Lista de todas as fontes relevantes (com citações no relatório)**
</Output Format>
 
<Citation Rules>
- Atribua a cada URL único um número de citação único no seu texto.
- Termine com ### Fontes, enumerando cada fonte com os números correspondentes.
- IMPORTANTE: Numere as fontes sequencialmente, sem saltos (1, 2, 3, 4...), na lista final, independentemente das fontes que escolher.
- Exemplo de formato:
  [1] Título da fonte: URL
  [2] Título da fonte: URL
</Citation Rules>
 
Lembrete importante: É extremamente importante que qualquer informação que seja remotamente relevante para o tema de pesquisa do usuário seja mantida textualmente (ou seja, não a reescreva, não a resuma, não a parafraseie).
"""
	
	

		
			
		
	
	
Copied

	

		
compress_research_human_message = """Todas as mensagens anteriores referem-se à pesquisa realizada por um pesquisador de IA sobre o seguinte tema de pesquisa:
 
TEMA DE PESQUISA: {research_topic}
 
Sua tarefa consiste em refinar os resultados desta pesquisa, conservando TODAS as informações relevantes para responder a esta questão de pesquisa específica.
 
REQUISITOS FUNDAMENTAIS:
- NÃO resuma nem parafraseie as informações: mantenha-as textualmente.
- NÃO perca nenhum detalhe, dado, nome, número ou descoberta específica
- NÃO filtre as informações que pareçam relevantes para o tema da pesquisa
- Organize as informações em um formato mais claro, mas mantenha todo o conteúdo
- Inclua TODAS as fontes e citações encontradas durante a pesquisa
- Lembre-se de que esta pesquisa foi realizada para responder à pergunta específica acima
 
Os resultados refinados serão usados para a elaboração do relatório final, por isso é fundamental que sejam exaustivos."""
	
	

		
			
		
	
	
Copied

	

		
from typing_extensions import TypedDict, Annotated, List, Sequence
 
class ResearcherState(TypedDict):
    """
    State for the research agent containing message history and research metadata.
    
    This state tracks the researcher's conversation, iteration count for limiting
    tool calls, the research topic being investigated, compressed findings,
    and raw research notes for detailed analysis.
    """
    researcher_messages: Annotated[Sequence[BaseMessage], add_messages]
    tool_call_iterations: int
    research_topic: str
    compressed_research: str
    raw_notes: Annotated[List[str], operator.add]
 
class ResearcherOutputState(TypedDict):
    """
    Output state for the research agent containing final research results.
    
    This represents the final output of the research process with compressed
    research findings and all raw notes from the research process.
    """
    compressed_research: str
    raw_notes: Annotated[List[str], operator.add]
    researcher_messages: Annotated[Sequence[BaseMessage], add_messages]
	
	

		
			
		
	
	
Copied

	

		
class Summary(BaseModel):
    """Schema for webpage content summarization."""
    summary: str = Field(description="Concise summary of the webpage content")
    key_excerpts: str = Field(description="Important quotes and excerpts from the content")
	
	

		
			
		
	
	
Copied

	

		
def tavily_search_multiple(
    search_queries: List[str],
    max_results: int = 3,
    topic: Literal["general", "news", "finance"] = "general",
    include_raw_content: bool = True,
) -> List[dict]:
    """Perform search using Tavily API for multiple queries.
 
    Args:
        search_queries: List of search queries to execute
        max_results: Maximum number of results per query
        topic: Topic filter for search results
        include_raw_content: Whether to include raw webpage content
 
    Returns:
        List of search result dictionaries
    """
    
    # Execute searches sequentially. Note: yon can use AsyncTavilyClient to parallelize this step.
    search_docs = []
    for query in search_queries:
        result = tavily_client.search(
            query,
            max_results=max_results,
            include_raw_content=include_raw_content,
            topic=topic
        )
        search_docs.append(result)
 
    return search_docs
	
	

		
			
		
	
	
Copied

	

		
def deduplicate_search_results(search_results: List[dict]) -> dict:
    """Deduplicate search results by URL to avoid processing duplicate content.
    
    Args:
        search_results: List of search result dictionaries
        
    Returns:
        Dictionary mapping URLs to unique results
    """
    unique_results = {}
    
    for response in search_results:
        for result in response['results']:
            url = result['url']
            if url not in unique_results:
                unique_results[url] = result
    
    return unique_results
	
	

		
			
		
	
	
Copied

	

		
def summarize_webpage_content(webpage_content: str) -> str:
    """Summarize webpage content using the configured summarization model.
    
    Args:
        webpage_content: Raw webpage content to summarize
        
    Returns:
        Formatted summary with key excerpts
    """
    try:
        # Set up structured output model for summarization
        structured_model = summarization_model.with_structured_output(Summary)
        
        # Generate summary
        summary = structured_model.invoke([
            HumanMessage(content=summarize_webpage_prompt.format(
                webpage_content=webpage_content,
                date=get_today_str()
            ))
        ])
        
        # Format summary with clear structure
        formatted_summary = (
            f"<summary>
{summary.summary}
</summary>

"
            f"<key_excerpts>
{summary.key_excerpts}
</key_excerpts>"
        )
        
        return formatted_summary
        
    except Exception as e:
        print(f"Failed to summarize webpage: {str(e)}")
        return webpage_content[:1000] + "..." if len(webpage_content) > 1000 else webpage_content
	
	

		
			
		
	
	
Copied

	

		
def process_search_results(unique_results: dict) -> dict:
    """Process search results by summarizing content where available.
    
    Args:
        unique_results: Dictionary of unique search results
        
    Returns:
        Dictionary of processed results with summaries
    """
    summarized_results = {}
    
    for url, result in unique_results.items():
        # Use existing content if no raw content for summarization
        if not result.get("raw_content"):
            content = result['content']
        else:
            # Summarize raw content for better processing
            content = summarize_webpage_content(result['raw_content'])
        
        summarized_results[url] = {
            'title': result['title'],
            'content': content
        }
    
    return summarized_results
	
	

		
			
		
	
	
Copied

	

		
def format_search_output(summarized_results: dict) -> str:
    """Format search results into a well-structured string output.
    
    Args:
        summarized_results: Dictionary of processed search results
        
    Returns:
        Formatted string of search results with clear source separation
    """
    if not summarized_results:
        return "No valid search results found. Please try different search queries or use a different search API."
    
    formatted_output = "Search results: 

"
    
    for i, (url, result) in enumerate(summarized_results.items(), 1):
        formatted_output += f"

--- SOURCE {i}: {result['title']} ---
"
        formatted_output += f"URL: {url}

"
        formatted_output += f"SUMMARY:
{result['content']}

"
        formatted_output += "-" * 80 + "
"
    
    return formatted_output
	
	

		
			
		
	
	
Copied

	

		
from langchain_core.tools import tool, InjectedToolArg
 
@tool(parse_docstring=True)
def tavily_search(
    query: str,
    max_results: Annotated[int, InjectedToolArg] = 3,
    topic: Annotated[Literal["general", "news", "finance"], InjectedToolArg] = "general",
) -> str:
    """Fetch results from Tavily search API with content summarization.
 
    Args:
        query: A single search query to execute
        max_results: Maximum number of results to return
        topic: Topic to filter results by ('general', 'news', 'finance')
    """
    # Execute search for single query
    search_results = tavily_search_multiple(
        [query], # Convert single query to list for the internal function
        max_results=max_results,
        topic=topic,
        include_raw_content=True,
    )
 
    # Deduplicate results by URL to avoid processing duplicate content
    unique_results = deduplicate_search_results(search_results)
 
    # Process results with summarization
    summarized_results = process_search_results(unique_results)
 
    # Format output for consumption
    return format_search_output(summarized_results)
	
	

		
			
		
	
	
Copied

{
"query": str,
"max_results": int,
"topic": Literal["geral", "notícias", "finanças"]
}

Tenho um buscador que:
- Recebe:
 - query (string): "Uma consulta de pesquisa simples"
 - max_results (int): "Número máximo de resultados a devolver"
 - tópico (Literal): "Categoria para filtrar ('general', 'news', 'finance')"

max_results: Annotated[int, InjectedToolArg] = 3,
topic: Annotado[Literal["general", "news", "finance"], InjectedToolArg] = "general",

Tenho um buscador que:
- Recebe:
 - query (string): "Uma consulta de pesquisa simples"

	

		
@tool(parse_docstring=True)
def think_tool(reflection: str = "") -> str:
    """Record your strategic reflection on research progress (REQUIRED).
 
    You MUST provide a detailed reflection analyzing your current findings,
    gaps, and next steps. Never call this tool without providing reflection text.
 
    Use this tool after each search to analyze results and plan next steps systematically.
    This creates a deliberate pause in the research workflow for quality decision-making.
 
    When to use:
    - After receiving search results: What key information did I find?
    - Before deciding next steps: Do I have enough to answer comprehensively?
    - When assessing research gaps: What specific information am I still missing?
    - Before concluding research: Can I provide a complete answer now?
 
    Args:
        reflection: (REQUIRED) Your detailed reflection on research progress, findings, gaps, and next steps.
                   Your reflection should include analysis of current findings, gap assessment,
                   quality evaluation, and strategic decision about next steps.
    """
    if not reflection:
        return "Reflection recorded: [No reflection provided]"
    return f"Reflection recorded: {reflection}"
	
	

		
			
		
	
	
Copied

	

		
from langchain.chat_models import init_chat_model
import os
import dotenv
 
dotenv.load_dotenv()
 
SUMMARIZATION_MODEL_NAME = "gpt-4.1-mini"
SUMMARIZATION_MODEL_PROVIDER = "openai"
SUMMARIZATION_MODEL_BASE_URL = "https://api.openai.com/v1"
SUMMARIZATION_MODEL_TEMPERATURE = 0.0
SUMMARIZATION_MODEL_PROVIDER_API_KEY = os.getenv("OPENAI_API_KEY")
 
summarization_model = init_chat_model(
    model=SUMMARIZATION_MODEL_NAME,
    model_provider=SUMMARIZATION_MODEL_PROVIDER,
    api_key=SUMMARIZATION_MODEL_PROVIDER_API_KEY,
    base_url=SUMMARIZATION_MODEL_BASE_URL,
    temperature=SUMMARIZATION_MODEL_TEMPERATURE
)
	
	

		
			
		
	
	
Copied

	

		
RESEARCH_MODEL_NAME = "anthropic:claude-sonnet-4-5-20250929"
ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")
RESEARCH_MODEL_MAX_TOKENS = 4096
 
research_model = init_chat_model(
    model=RESEARCH_MODEL_NAME,
    max_tokens=RESEARCH_MODEL_MAX_TOKENS
)
	
	

		
			
		
	
	
Copied

	

		
researcher_tools = [tavily_search, think_tool]
 
model_with_tools = research_model.bind_tools(researcher_tools)
	
	

		
			
		
	
	
Copied

	

		
COMPRESS_MODEL_NAME = "gpt-4.1"
COMPRESS_MODEL_PROVIDER = "openai"
COMPRESS_MODEL_BASE_URL = "https://api.openai.com/v1"
COMPRESS_MODEL_TEMPERATURE = 0.0
COMPRESS_MODEL_PROVIDER_API_KEY = os.getenv("OPENAI_API_KEY")
 
compress_model = init_chat_model(
    model=COMPRESS_MODEL_NAME,
    model_provider=COMPRESS_MODEL_PROVIDER,
    api_key=COMPRESS_MODEL_PROVIDER_API_KEY,
    base_url=COMPRESS_MODEL_BASE_URL,
    temperature=COMPRESS_MODEL_TEMPERATURE,
    max_tokens=32000
)
	
	

		
			
		
	
	
Copied