Upload 3 files

agente_functions.py

@@ -0,0 +1,94 @@
+# agente_functions.py
+
+from typing import TypedDict, List
+from langchain_core.tools import tool
+from langchain_community.tools.tavily_search import TavilySearchResults
+from langchain.agents import load_tools
+from langgraph.prebuilt import create_react_agent
+
+# --- Define a estrutura de estado do grafo ---
+class AgentState(TypedDict):
+    user_query: str
+    router_decision: str
+    web_answer: str
+    scientific_answer: str
+    final_answer: str
+
+# --- Ferramentas e Funções dos Agentes ---
+
+@tool
+def busca_web(query: str) -> list:
+  """
+  Busca na web por um termo específico usando Tavily Search.
+  """
+  tavily_search = TavilySearchResults(max_results=2, search_depth='advanced', max_tokens=1000)
+  resultado_busca = tavily_search.invoke(query)
+  return resultado_busca
+
+def funcao_agente_web(state: AgentState, llm, tools: List) -> dict:
+  """
+  Executa um agente ReAct que realiza uma busca na web.
+  """
+  system_prompt = """Atue como um assistente útil.
+    Use as ferramentas fornecidas para responder às perguntas do usuário.
+    - busca_web: Retorna os resultados de uma busca na web.
+    Use a busca_web sempre que o usuário fizer uma pergunta sobre um tema específico e retorne o link dos artigos na resposta.
+  """
+  agente_web = create_react_agent(model=llm, tools=tools, prompt=system_prompt)
+  resultado = agente_web.invoke({"messages": [("user", state["user_query"])]})
+  resposta_final = resultado['messages'][-1].content
+  return {"web_answer": resposta_final}
+
+def funcao_agente_cientifico(state: AgentState, llm, tools: List) -> dict:
+    """
+    Executa um agente ReAct que realiza uma busca no Arxiv.
+    """
+    system_prompt = """Atue como um assistente útil.
+    Use as ferramentas fornecidas para responder às perguntas do usuário.
+    - tool_cientifica: Retorna os resultados de uma busca no arxiv.
+    Use a tool_cientifica sempre que o usuário fizer uma pergunta sobre um tema específico e retorne o título dos artigos na resposta.
+    """
+    agente_cientifico = create_react_agent(llm, tools, prompt=system_prompt)
+    resultado = agente_cientifico.invoke({"messages": [("user", state["user_query"])]})
+    resposta_final = resultado['messages'][-1].content
+    return {"scientific_answer": resposta_final}
+
+def router_agent(state: AgentState, llm) -> dict:
+    """
+    Agente roteador que decide qual ferramenta usar com base na query do usuário.
+    """
+    router_prompt_template = """Você é um agente roteador. Sua tarefa é decidir qual o agente é mais apropriado para responder à pergunta do usuário.
+    Se a pergunta mencionar explicitamente "fontes da web", "notícias" ou for de natureza geral, escolha 'web_search'.
+    Se a pergunta mencionar "artigos científicos", "pesquisas", "estudos" ou for de natureza técnica/acadêmica, escolha 'scientific_search'.
+    Para perguntas gerais sem especificação, prefira 'web_search'.
+
+    Pergunta do usuário: {user_query}
+
+    Responda APENAS com o nome da opção escolhida: 'web_search' ou 'scientific_search'.
+    """
+    prompt = router_prompt_template.format(user_query=state["user_query"])
+    response = llm.invoke(prompt)
+    decision = response.content.strip().lower()
+
+    if "scientific_search" in decision:
+        return {"router_decision": "scientific_search"}
+    else:
+        return {"router_decision": "web_search"}
+
+def supervisor_node(state: AgentState) -> dict:
+    """
+    Combina os resultados dos outros nós e formata a resposta final.
+    """
+    web_results = state.get("web_answer", "Não foi realizada pesquisa na Web.")
+    scientific_results = state.get("scientific_answer", "Não foi realizada pesquisa por artigos científicos.")
+
+    # Constrói a resposta final baseada nos resultados disponíveis
+    final_answer = "## Resultados da Pesquisa\n\n"
+    if state.get("web_answer"):
+        final_answer += "### Resultados da Pesquisa na Web\n"
+        final_answer += web_results
+    if state.get("scientific_answer"):
+        final_answer += "\n\n### Resultados de Artigos Científicos\n"
+        final_answer += scientific_results
+
+    return {"final_answer": final_answer}

main.py

@@ -0,0 +1,97 @@
+# main.py
+
+import os
+import gradio as gr
+from functools import partial
+
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain.agents import load_tools
+from langgraph.graph import StateGraph, START, END
+
+# Importa as funções e a classe de estado do outro arquivo
+from agente_functions import (
+    AgentState,
+    busca_web,
+    funcao_agente_web,
+    funcao_agente_cientifico,
+    supervisor_node,
+    router_agent
+)
+
+# --- 1. Configuração do Ambiente ---
+# É recomendado carregar as chaves de um arquivo .env para segurança
+# from dotenv import load_dotenv
+# load_dotenv()
+# api_key = os.getenv("GOOGLE_API_KEY")
+# tavily_api_key = os.getenv("TAVILY_API_KEY")
+
+# Para este exemplo, vamos supor que as chaves estão como variáveis de ambiente
+os.environ["GOOGLE_API_KEY"] = "SUA_CHAVE_API_GEMINI_AQUI"
+os.environ["TAVILY_API_KEY"] = "SUA_CHAVE_API_TAVILY_AQUI"
+
+if not os.environ.get("GOOGLE_API_KEY") or not os.environ.get("TAVILY_API_KEY"):
+    print("Por favor, defina as variáveis de ambiente GOOGLE_API_KEY e TAVILY_API_KEY.")
+    exit()
+
+# --- 2. Inicialização do Modelo e Ferramentas ---
+llm = ChatGoogleGenerativeAI(model="gemini-1.5-flash")
+web_tools = [busca_web]
+scientific_tools = load_tools(["arxiv"])
+
+
+# --- 3. Construção do Grafo com LangGraph ---
+workflow = StateGraph(AgentState)
+
+# Usando functools.partial para passar argumentos fixos (llm, tools) para as funções dos nós
+web_search_node = partial(funcao_agente_web, llm=llm, tools=web_tools)
+scientific_search_node = partial(funcao_agente_cientifico, llm=llm, tools=scientific_tools)
+router_node = partial(router_agent, llm=llm)
+
+# Adiciona os nós ao grafo
+workflow.add_node("router", router_node)
+workflow.add_node("web_search", web_search_node)
+workflow.add_node("scientific_search", scientific_search_node)
+workflow.add_node("supervisor", supervisor_node)
+
+# Define as arestas (fluxo de trabalho)
+workflow.add_edge(START, "router")
+workflow.add_conditional_edges(
+    "router",
+    lambda state: state['router_decision'],
+    {
+        "web_search": "web_search",
+        "scientific_search": "scientific_search"
+    }
+)
+workflow.add_edge("web_search", "supervisor")
+workflow.add_edge("scientific_search", "supervisor")
+workflow.add_edge("supervisor", END)
+
+# Compila o grafo para torná-lo executável
+app = workflow.compile()
+
+# --- 4. Função para Interface do Gradio ---
+def run_graph(user_query: str) -> str:
+    """
+    Executa o grafo do LangGraph com a pergunta do usuário e retorna a resposta final.
+    """
+    try:
+        result = app.invoke({"user_query": user_query})
+        # Retorna a resposta final do supervisor, com um fallback
+        return result.get("final_answer", "Não foi possível obter uma resposta final.")
+    except Exception as e:
+        return f"Ocorreu um erro: {e}"
+
+# --- 5. Lançamento da Aplicação com Gradio ---
+if __name__ == "__main__":
+    print("Iniciando a interface do Gradio...")
+    iface = gr.Interface(
+        fn=run_graph,
+        inputs=gr.Textbox(lines=2, label="Digite sua pergunta:", placeholder="Ex: Qual o impacto da IA na medicina?"),
+        outputs=gr.Markdown(label="Resposta do Agente"),
+        title="🤖 Agente de Pesquisa com LangGraph e Gemini",
+        description="Faça uma pergunta e o sistema decidirá se busca na web, em artigos científicos, ou ambos, para construir a melhor resposta.",
+        allow_flagging="never"
+    )
+
+    iface.launch()

requirements.txt

@@ -0,0 +1,11 @@
+# requirements.txt
+
+google-ai-generativelanguage==0.6.15
+langchain-google-genai
+langchain
+langchain-pinecone
+langchain-community
+langgraph
+arxiv
+tavily-client
+gradio