go

.gitignore

@@ -0,0 +1,11 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+.env

.python-version

@@ -0,0 +1 @@
+3.12

agent.py

@@ -0,0 +1,83 @@
+import os
+from dotenv import load_dotenv
+
+from pydantic_ai import Agent, RunContext
+# from pydantic_ai.messages import (ModelMessage, ModelRequest, ModelResponse, UserPromptPart, 
+#                                   SystemPromptPart, TextPart, ModelMessagesTypeAdapter,
+#                                   ToolReturnPart)
+from pydantic_ai.usage import UsageLimits
+from pydantic_core import to_jsonable_python
+from pydantic_ai.models.groq import GroqModel    
+
+from dataclasses import dataclass
+
+from dotenv import load_dotenv
+load_dotenv()
+
+from tools.searching import SearchingTools
+
+
+
+# Defina um prompt de sistema padrão
+DEFAULT_SYSTEM_PROMPT = f"""
+Você é um agente assistente em um programa de detecção de conteúdos falsos (fake news).
+Intereja com o usuário sugerindo as ferramentas que você tem disponível. Se o usuário perguntar do que se trata,
+responda 'Sou uma IA disponível para te ajudar a detectar se um conteúdo que circula na internet é verdadeiro ou não,
+sou capaz de pesquisar na web se o conteúdo é verídico ou não.' Use as ferramenta sempre que possível. 
+A data de hoje é {data_formatada}.
+Anexe sempre a fonte da pesquisa na resposta (G1, BBC, New York Times, etc), se houver fonte na pesquisa utilizada.
+Não invente fontes, não invente dados. Se não houver nada relacionado à pergunta do usuário nas pesquisas, diga que nada foi encontrado.
+Responda sempre em português do Brasil.
+Limite-se a 600 caracteres.
+"""
+
+@dataclass
+class SearchAgentDeps:
+    tools: SearchingTools
+    
+api_key = os.getenv("GROQ_API_KEY")
+model = GroqModel(
+    model_name="openai/gpt-oss-120b"
+)
+
+
+def start_convo(user_input, messages_history):
+    search_agent = Agent(
+        model,
+        deps_type=SearchAgentDeps,
+        system_prompt=DEFAULT_SYSTEM_PROMPT,
+        history_processors=[context_aware_processor]
+    )
+    @search_agent.tool(name="procura_web_noticias_detectadas_como_fake_news",retries=3)
+    def procura_web_noticias_detectadas_como_fake_news(ctx: RunContext[SearchAgentDeps], search_query: str) -> str:
+        """Pesquisa em um canal de coleta de Fake News Brasileira"""
+        return ctx.deps.tools.search_web(
+            search_query=search_query, 
+            include_domains=["https://g1.globo.com/fato-ou-fake/"],
+            max_results=15
+        )
+
+    @search_agent.tool(name="pesquisa_web_global", retries=3)
+    def pesquisa_web_global(ctx: RunContext[SearchAgentDeps], search_query: str) -> str:
+        """Pesquisa na web de maneira geral"""
+        return ctx.deps.tools.search_web(
+            search_query=search_query, 
+            exclude_domains=["https://g1.globo.com/fato-ou-fake/"],
+            max_results=7
+        )
+        
+    @search_agent.tool(name="pesquisa_social_media_verificados", retries=3)
+    def pesquisa_social_media_verificados(ctx: RunContext[SearchAgentDeps], search_query: str) -> str:
+        """Pesquisa na web de maneira geral"""
+        return ctx.deps.tools.search_web(
+            search_query=search_query, 
+            include_domains=[
+                "https://x.com/OGloboPolitica",
+                "https://x.com/CNNBrasil",
+                "https://x.com/recordnews",
+                "https://x.com/JovemPanNews"
+            ],
+            max_results=15
+        )
+        
+    return search_agent

app.py

@@ -1,70 +1,37 @@
 import gradio as gr
-from huggingface_hub import InferenceClient
+import uuid
+from agent import start_convo
+from utils.history import convert_to_pydantic_history, context_aware_processor
 
+# Generate a unique user ID for the session
+USER_ID = str(uuid.uuid4())
 
-def respond(
-    message,
-    history: list[dict[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-    hf_token: gr.OAuthToken,
-):
-    """
-    For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-    """
-    client = InferenceClient(token=hf_token.token, model="openai/gpt-oss-20b")
+from tools.searching import SearchingTools  # Importe aqui
+from agent import SearchAgentDeps  # Importe se necessário (baseado no seu código anterior)
+from pydantic_ai import UsageLimits
 
-    messages = [{"role": "system", "content": system_message}]
+import asyncio 
 
-    messages.extend(history)
-
-    messages.append({"role": "user", "content": message})
-
-    response = ""
-
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        choices = message.choices
-        token = ""
-        if len(choices) and choices[0].delta.content:
-            token = choices[0].delta.content
-
-        response += token
-        yield response
-
-
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-chatbot = gr.ChatInterface(
-    respond,
-    type="messages",
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
+from client_agent import agent_startup
+usage_limits=UsageLimits(
+    output_tokens_limit=10000,
+    tool_calls_limit=10
 )
-
-with gr.Blocks() as demo:
-    with gr.Sidebar():
-        gr.LoginButton()
-    chatbot.render()
-
+def respond(message, history): 
+    #pydantic_history_messages = convert_to_pydantic_history(history)
+    # Append the user's message with a placeholder for the bot's response
+    message = str(message)
+    print(f"Message received: {message}")
+    tools_instance = SearchingTools()
+    
+    
+    result = asyncio.run(agent_startup(message)) 
+    
+    print(f"Result: {result}")
+    # Adicione a nova resposta ao histórico original (se precisar manter)
+    
+    return result
 
 if __name__ == "__main__":
-    demo.launch()
+    demo = gr.ChatInterface(fn=respond, type="messages", title="Fake News Detector Bot", save_history=True)
+    demo.launch(ssr_mode=False)

client_agent.py

@@ -0,0 +1,187 @@
+import asyncio
+from pydantic_ai import Agent, RunContext
+from pydantic_ai.mcp import MCPServerStreamableHTTP
+from pydantic_ai.models.openai import OpenAIChatModel
+from pydantic_ai.providers.openrouter import OpenRouterProvider
+from pydantic_ai.providers.groq import GroqProvider
+from pydantic_ai.models.groq import GroqModel
+from tools.searching import SearchingTools
+
+from dotenv import load_dotenv
+load_dotenv()
+import os
+
+# Criar servidor MCP via stdio
+neo4j_server = MCPServerStreamableHTTP(
+    url = "http://127.0.0.1:8000/mcp"
+)
+
+SYSTEM_PROMPT = """
+You are an Expert Football Analyst with access to Barcelona graphdatabase from 2016 to 2020.
+Use the tools available to respond the user query.
+Base your analysis **ONLY** by the query results. If the database can't provide what the user is 
+asking for, report that in a professional way.
+Below you can find some cypher queries as example, so you can understand which artifacts and metadatas are available in the database:
+
+// General Overview: players, connections, goals per temporada
+MATCH (p:Player {team: "Barcelona"})
+OPTIONAL MATCH (p)-[r:PASSED_TO]->()
+OPTIONAL MATCH (g:GoalSequence {team: "Barcelona"})
+RETURN 
+    count(DISTINCT p) as TotalPlayers,
+    count(DISTINCT r) as TotalPassConnections,
+    sum(r.weight) as TotalPasses,
+    count(DISTINCT g) as TotalGoalSequences,
+    collect(DISTINCT p.season_date) as Seasons
+// List all seasons available in neo4j
+MATCH (p:Player)
+RETURN DISTINCT p.season_date as Season, p.season_id as SeasonID
+ORDER BY p.season_date
+// Top 5 connections per season
+MATCH (p1:Player)-[r:PASSED_TO]->(p2:Player)
+WITH p1.season_date as Season, p1.name as P1, p2.name as P2, r.weight as Weight
+ORDER BY Weight DESC
+WITH Season, collect({passer: P1, receiver: P2, passes: Weight})[0..5] as TopConnections
+RETURN Season, TopConnections
+ORDER BY Season
+// Connections between different zones in field
+MATCH (p1:Player)-[r:PASSED_TO]->(p2:Player)
+WHERE p1.season_id = 90
+WITH p1, p2, r,
+     CASE WHEN p1.avg_x < 40 THEN 'Def' WHEN p1.avg_x < 80 THEN 'Mid' ELSE 'Att' END as Zone1,
+     CASE WHEN p2.avg_x < 40 THEN 'Def' WHEN p2.avg_x < 80 THEN 'Mid' ELSE 'Att' END as Zone2
+WHERE Zone1 <> Zone2
+RETURN Zone1 + ' -> ' + Zone2 as Transition, sum(r.weight) as TotalPasses
+ORDER BY TotalPasses DESC
+// Total number of sequences of goals that Rakitić (a player) was involved
+MATCH (p:Player {name: "Ivan Rakitić"})-[:INVOLVED_IN]->(g:GoalSequence)
+RETURN count(g) as TotalGoalSequences
+
+The Property Keys available are: avg_x, avg_y, data, end_x, end_y, id, match_id, name, nodes, num_passes, order, possession, relationships, season_date, season_id, sequence_id, style, team, visualisation, weight, x, y.
+The Nodes are: Player, GoalSequence.
+The Relationships are: INVOLVED_IN, PASSED_IN_SEQUENCE, PASSED_TO.
+
+All players played in all seasons are:
+Abel Ruiz Ortega
+Aleix Vidal Parreu
+André Filipe Tavares Gomes
+Andrés Iniesta Luján
+Anssumane Fati
+Antoine Griezmann
+Arda Turan
+Arthur Henrique Ramos de Oliveira Melo
+Arturo Erasmo Vidal Pardo
+Carles Aleña Castillo
+Carles Pérez Sayol
+Claudio Andrés Bravo Muñoz
+Clément Lenglet
+Denis Suárez Fernández
+Francisco Alcácer García
+Francisco António Machado Mota de Castro Trincão
+Frenkie de Jong
+Gerard Deulofeu Lázaro
+Gerard Piqué Bernabéu
+Héctor Junior Firpo Adames
+Ivan Rakitić
+Jasper Cillessen
+Javier Alejandro Mascherano
+Jean-Clair Todibo
+Jordi Alba Ramos
+José Manuel Arnáiz Díaz
+José Paulo Bezzera Maciel Júnior
+Jérémy Mathieu
+Kevin-Prince Boateng
+Lionel Andrés Messi Cuccittini
+Lucas Digne
+Luis Alberto Suárez Díaz
+Malcom Filipe Silva de Oliveira
+Marc-André ter Stegen
+Marlon Santos da Silva Barbosa
+Martin Braithwaite Christensen
+Miralem Pjanić
+Moriba Kourouma Kourouma
+Moussa Wagué
+Munir El Haddadi Mohamed
+Neymar da Silva Santos Junior
+Norberto Murara Neto
+Nélson Cabral Semedo
+Ousmane Dembélé
+Pedro González López
+Philippe Coutinho Correia
+Rafael Alcântara do Nascimento
+Ricard Puig Martí
+Ronald Federico Araújo da Silva
+Samuel Yves Umtiti
+Sergi Roberto Carnicer
+Sergino Dest
+Sergio Busquets i Burgos
+Thomas Vermaelen
+Yerry Fernando Mina González
+Álex Collado Gutiérrez
+Óscar Mingueza García
+"""
+
+
+
+
+api_key = os.getenv("GROQ_API_KEY")
+groq_model = GroqModel(
+    "openai/gpt-oss-20b",
+    provider=GroqProvider(api_key=api_key)
+)
+
+@dataclass
+class SearchAgentDeps:
+    tools: SearchingTools
+    
+# Criar agent com o servidor MCP
+agent = Agent(
+    model=groq_model,
+    toolsets=[neo4j_server],
+    system_prompt=SYSTEM_PROMPT,
+    deps_type=SearchAgentDeps,
+)
+
+tools_instance = SearchingTools()
+deps = SearchAgentDeps(tools=tools_instance)
+
+@search_agent.tool(name="web_search",retries=3)
+def procura_web(ctx: RunContext[SearchAgentDeps], search_query: str) -> str:
+    """Pesquisa na web"""
+    return ctx.deps.tools.search_web(
+        search_query=search_query,
+        max_results=15
+    )
+
+async def agent_startup(user_query):
+    async with agent:  # Gerencia a conexão MCP automaticamente
+        # Exemplo 1: Análise do Rakitić
+        print("=" * 60)
+        result1 = await agent.run(
+            user_prompt=user_query
+        )
+        print(result1.output)
+        return result1.output
+        # # Exemplo 2: Cadeias de passes
+        # print("\n" + "=" * 60)
+        # result2 = await agent.run(
+        #     "Mostre as 5 cadeias de 2 passes mais frequentes do Rakitić"
+        # )
+        # print(result2.output)
+        
+        # # Exemplo 3: Eficiência
+        # print("\n" + "=" * 60)
+        # result3 = await agent.run(
+        #     "Qual a eficiência do Rakitić? Compare passes totais com passes que resultam em gol. Compare com outros jogadores."
+        # )
+        # print(result3.output)
+        
+        # # Exemplo 4: Query customizada
+        # print("\n" + "=" * 60)
+        # result4 = await agent.run(
+        #     "List the 5 top players that participated in goals, each season"
+        # )
+        # print(result4.output)
+
+if __name__ == '__main__':
+    asyncio.run(main())

main.py

@@ -0,0 +1,6 @@
+def main():
+    print("Hello from hf-barca-neo4j-agent!")
+
+
+if __name__ == "__main__":
+    main()

mcp_server.py

@@ -0,0 +1,356 @@
+import os
+from typing import Optional, List, Dict, Any
+from dotenv import load_dotenv
+from neo4j import GraphDatabase
+from mcp.server.fastmcp import FastMCP, Context
+
+# Carregar variáveis de ambiente
+load_dotenv()
+
+# Configuração do Neo4j
+NEO4J_URI = os.getenv("NEO4J_URI")
+NEO4J_USER = os.getenv("NEO4J_USER")
+NEO4J_PASSWORD = os.getenv("NEO4J_PASSWORD")
+
+# Criar conexão global Neo4j
+class Neo4jConnection:
+    def __init__(self):
+        self.driver = GraphDatabase.driver(
+            NEO4J_URI, 
+            auth=(NEO4J_USER, NEO4J_PASSWORD)
+        )
+        print(f"✓ Conectado ao Neo4j: {NEO4J_URI}")
+    
+    def execute_query(self, query: str, parameters: Optional[Dict[str, Any]] = None):
+        with self.driver.session() as session:
+            result = session.run(query, parameters or {})
+            return [record.data() for record in result]
+    
+    def close(self):
+        self.driver.close()
+
+# Instância global
+neo4j = Neo4jConnection()
+
+# Criar servidor MCP
+mcp = FastMCP(name="Neo4j Football Analytics")
+
+# Tool 1: Query Cypher customizada
+@mcp.tool()
+async def execute_cypher_query(
+    query: str,
+    parameters: Optional[Dict[str, Any]] = None,
+    limit: int = 100
+) -> str:
+    """
+    Executa uma query Cypher READ-ONLY no banco de dados Neo4j.
+    
+    Args:
+        query: Query Cypher a ser executada (apenas MATCH/RETURN)
+        parameters: Dicionário de parâmetros opcionais
+        limit: Número máximo de resultados (padrão: 100)
+    
+    Returns:
+        String formatada com os resultados da query
+    """
+    # Validação de segurança
+    query_upper = query.upper().strip()
+    dangerous = ['DELETE', 'DETACH', 'REMOVE', 'SET', 'CREATE', 'MERGE', 'DROP']
+    
+    if any(keyword in query_upper for keyword in dangerous):
+        return "❌ ERRO: Apenas queries de leitura (MATCH/RETURN) são permitidas."
+    
+    try:
+        # Adicionar LIMIT se não existir
+        if 'LIMIT' not in query_upper:
+            query += f" LIMIT {limit}"
+        
+        results = neo4j.execute_query(query, parameters)
+        
+        if not results:
+            return "✓ Query executada, mas nenhum resultado encontrado."
+        
+        # Formatar resultados
+        output = [f"📊 Resultados ({len(results)} encontrados):\n"]
+        
+        for i, record in enumerate(results[:10], 1):
+            items = [f"{k}={v}" for k, v in record.items()]
+            output.append(f"{i}. {', '.join(items)}")
+        
+        if len(results) > 10:
+            output.append(f"\n... e mais {len(results) - 10} resultados.")
+        
+        return "\n".join(output)
+        
+    except Exception as e:
+        return f"❌ Erro ao executar query: {str(e)}"
+    
+@mcp.tool()
+def search_goal_sequences_by_player(
+    player_name: str,
+    limit: int = 10
+) -> str:
+    """
+    Busca sequências de gol que começam com passes de um jogador específico.
+    
+    Args:
+        player_name: Nome do jogador (ex: "Ivan Rakitić")
+        limit: Número máximo de resultados a retornar
+    """
+    query = """
+    MATCH (p:Player {name: $player_name})-[:INVOLVED_IN]->(g:GoalSequence)
+    RETURN count(g) as TotalGoalSequences
+    """
+    
+    try:
+        results = neo4j.execute_query(query, {"player_name": player_name})
+        
+        if not results:
+            return f"Nenhuma sequência de gol encontrada para {player_name}"
+        
+        total = results[0].get('TotalGoalSequences', 0)
+        return f"## Análise de {player_name}:\n{player_name} participou de {total} sequências que resultaram em gol."
+        
+    except Exception as e:
+        return f"Erro ao executar query: {str(e)}"
+
+# Tool 2: Análise de sequências de gol por jogador
+@mcp.tool()
+def analyze_pass_chains(
+    player_name: str,
+    chain_length: int = 2,
+    limit: int = 10
+) -> str:
+    """
+    Analisa caminhos de passes de comprimento específico começando por um jogador.
+    
+    Args:
+        player_name: Nome do jogador inicial
+        chain_length: Comprimento da cadeia de passes (número de passes)
+        limit: Número máximo de cadeias a retornar
+    """
+    query = f"""
+    MATCH path = (p1:Player {{name: $player_name}})-[:PASSED_TO*{chain_length}]->(p2:Player)
+    RETURN p1.name as Start, 
+           p2.name as End,
+           [node IN nodes(path) | node.name] as PassChain,
+           count(path) as Frequency
+    ORDER BY Frequency DESC
+    LIMIT $limit
+    """
+    
+    try:
+        results = neo4j.execute_query(
+            query, 
+            {"player_name": player_name, "limit": limit}
+        )
+        
+        if not results:
+            return f"Nenhuma cadeia de {chain_length} passes encontrada para {player_name}"
+        
+        # Formatar resultados
+        return_data = [f"## Cadeias de Passes de {player_name}:\n"]
+        
+        for i, record in enumerate(results[:5], 1):  # Top 5 cadeias
+            chain = " → ".join(record['PassChain'])
+            freq = record['Frequency']
+            return_data.append(f"{i}. {chain} (Frequência: {freq})")
+        
+        return "\n".join(return_data)
+        
+    except Exception as e:
+        return f"Erro ao executar query: {str(e)}"
+    
+@mcp.tool()
+async def count_goal_initiations(
+    player_name: str
+) -> str:
+    """
+    Conta quantos gols/chutes começam com passes de um jogador específico.
+    
+    Args:
+        player_name: Nome do jogador a analisar
+    """
+    query = """
+    MATCH (rak:Player {name: $player_name})-[r:PASSED_IN_SEQUENCE]->(receiver:Player)
+    WITH rak, receiver, r, r.sequence_id as seqId
+    MATCH (g:GoalSequence {sequence_id: seqId})
+    RETURN receiver.name as PassedTo,
+           count(DISTINCT seqId) as NumberOfGoalSequences,
+           avg(r.order) as AvgPassPosition,
+           collect(DISTINCT g.match_id)[0..3] as SampleMatches
+    ORDER BY NumberOfGoalSequences DESC
+    LIMIT 5
+    """
+    
+    try:
+        results = neo4j.execute_query(query, {"player_name": player_name})
+        
+        if not results:
+            return f"Nenhum dado encontrado para {player_name}"
+        
+        return_data = [f"## Estatísticas de Gol - {player_name}:\n"]
+        
+        for record in results:
+            receiver = record['PassedTo']
+            goals = record['NumberOfGoalSequences']
+            avg_pos = round(record['AvgPassPosition'], 2)
+            return_data.append(
+                f"→ Para {receiver}: {goals} sequências de gol (posição média no passe: {avg_pos})"
+            )
+        
+        return "\n".join(return_data)
+        
+    except Exception as e:
+        return f"Erro ao executar query: {str(e)}"
+
+# Tool 3: Cadeias de passes
+@mcp.tool()
+async def analyze_pass_chains(
+    player_name: str,
+    chain_length: int = 2,
+    top_n: int = 5
+) -> str:
+    """
+    Analisa cadeias de passes começando por um jogador.
+    
+    Args:
+        player_name: Nome do jogador inicial
+        chain_length: Comprimento da cadeia (número de passes)
+        top_n: Número de cadeias mais frequentes a retornar
+    
+    Returns:
+        Análise das cadeias de passes mais frequentes
+    """
+    query = f"""
+    MATCH path = (p1:Player {{name: $player_name}})-[:PASSED_TO*{chain_length}]->(p2:Player)
+    WITH [node IN nodes(path) | node.name] as PassChain, count(path) as Frequency
+    RETURN PassChain, Frequency
+    ORDER BY Frequency DESC
+    LIMIT $top_n
+    """
+    
+    try:
+        results = neo4j.execute_query(
+            query, 
+            {"player_name": player_name, "top_n": top_n}
+        )
+        
+        if not results:
+            return f"❌ Nenhuma cadeia de {chain_length} passes encontrada para {player_name}"
+        
+        output = [f"🔗 Top {len(results)} cadeias de {chain_length} passes de {player_name}:\n"]
+        
+        for i, record in enumerate(results, 1):
+            chain = " → ".join(record['PassChain'])
+            freq = record['Frequency']
+            output.append(f"{i}. {chain} (frequência: {freq})")
+        
+        return "\n".join(output)
+        
+    except Exception as e:
+        return f"❌ Erro: {str(e)}"
+
+# Tool 4: Eficiência de passes em gols
+@mcp.tool()
+async def player_efficiency(player_name: str) -> str:
+    """
+    Calcula a eficiência de um jogador: passes totais vs passes que resultam em gol.
+    
+    Args:
+        player_name: Nome do jogador a analisar
+    
+    Returns:
+        Estatísticas de eficiência formatadas
+    """
+    query = """
+    MATCH (p:Player {name: $player_name})
+    OPTIONAL MATCH (p)-[total:PASSED_TO]->()
+    OPTIONAL MATCH (p)-[goals:PASSED_IN_SEQUENCE]->()
+    WITH p,
+         sum(total.weight) as TotalPasses,
+         count(DISTINCT goals) as PassesInGoals
+    RETURN p.name as Player,
+           TotalPasses,
+           PassesInGoals,
+           CASE 
+               WHEN TotalPasses > 0 
+               THEN round(PassesInGoals * 100.0 / TotalPasses, 2)
+               ELSE 0
+           END as EfficiencyPercent
+    """
+    
+    try:
+        results = neo4j.execute_query(query, {"player_name": player_name})
+        
+        if not results or not results[0]['TotalPasses']:
+            return f"❌ Dados insuficientes para {player_name}"
+        
+        r = results[0]
+        output = [
+            f"📈 Eficiência de {r['Player']}:",
+            f"Total de passes: {r['TotalPasses']}",
+            f"Passes em sequências de gol: {r['PassesInGoals']}",
+            f"Taxa de eficiência: {r['EfficiencyPercent']}%"
+        ]
+        
+        return "\n".join(output)
+        
+    except Exception as e:
+        return f"❌ Erro: {str(e)}"
+
+# Tool 5: Estatísticas específicas do Rakitić
+@mcp.tool()
+async def rakitic_goal_statistics() -> str:
+    """
+    Retorna estatísticas detalhadas de Ivan Rakitić em sequências de gol.
+    
+    Returns:
+        Análise completa do desempenho de Rakitić
+    """
+    query = """
+    MATCH (rak:Player {name: "Ivan Rakitić"})-[r:PASSED_IN_SEQUENCE]->(receiver:Player)
+    WITH rak, receiver, r, r.sequence_id as seqId
+    MATCH (g:GoalSequence {sequence_id: seqId})
+    RETURN receiver.name as PassedTo,
+           count(DISTINCT seqId) as NumberOfGoalSequences,
+           round(avg(r.order), 2) as AvgPassPosition,
+           collect(DISTINCT g.match_id)[0..3] as SampleMatches
+    ORDER BY NumberOfGoalSequences DESC
+    LIMIT 10
+    """
+    
+    try:
+        results = neo4j.execute_query(query)
+        
+        if not results:
+            return "❌ Nenhum dado encontrado para Ivan Rakitić"
+        
+        output = ["⭐ Estatísticas de Ivan Rakitić em Sequências de Gol:\n"]
+        
+        total_sequences = sum(r['NumberOfGoalSequences'] for r in results)
+        output.append(f"Total de sequências envolvidas: {total_sequences}\n")
+        output.append("🎯 Principais destinatários de passes:")
+        
+        for i, record in enumerate(results, 1):
+            output.append(
+                f"{i}. {record['PassedTo']}: {record['NumberOfGoalSequences']} sequências "
+                f"(posição média: {record['AvgPassPosition']})"
+            )
+        
+        return "\n".join(output)
+        
+    except Exception as e:
+        return f"❌ Erro: {str(e)}"
+
+# Executar servidor
+if __name__ == '__main__':
+    async def run():
+        try:
+            # Escolher transporte: 'stdio', 'sse', ou 'streamable-http'
+            print("🚀 Iniciando servidor MCP Neo4j...")
+            await mcp.run_streamable_http_async()  # Usar 'streamable-http' para HTTP
+        finally:
+            neo4j.close()
+    import asyncio
+    asyncio.run(run())

pyproject.toml

@@ -0,0 +1,10 @@
+[project]
+name = "hf-barca-neo4j-agent"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "pydantic-ai>=1.1.0",
+    "tavily-python>=0.7.12",
+]

tools/searching.py

@@ -0,0 +1,44 @@
+import os
+from tavily import TavilyClient
+
+tavily_api_key = os.getenv("TAVILY_API_KEY")
+tavily_api_key_2 = os.getenv("TAVILY_API_KEY_2")
+
+class SearchingTools:
+    def search_web(
+        self,
+        search_query: str, 
+        max_results: int = 3, 
+        include_domains: list = None, 
+        exclude_domains: list = None
+    ) -> str:
+        try:
+            # Tente a primeira chave
+            tavily = TavilyClient(api_key=tavily_api_key)
+            search_results = tavily.search(
+                query=search_query,
+                max_results=max_results,
+                include_domains=include_domains,
+                exclude_domains=exclude_domains
+            )
+        except Exception as e:
+            # Fallback para a segunda chave se a primeira falhar
+            if tavily_api_key_2:
+                try:
+                    tavily = TavilyClient(api_key=tavily_api_key_2)
+                    search_results = tavily.search(
+                        query=search_query,
+                        max_results=max_results,
+                        include_domains=include_domains,
+                        exclude_domains=exclude_domains
+                    )
+                except Exception as fallback_e:
+                    return f"Erro na busca: {str(fallback_e)}"
+            else:
+                return f"Erro na busca: {str(e)}"
+        
+        raw_data = []
+        for result in search_results.get('results', []):
+            raw_data.append(f"Url: {result['url']} {result['title']}: {result['content'][:1500]}")
+        
+        return " ".join(raw_data) if raw_data else "Nenhum resultado encontrado."