go

Dockerfile

@@ -1,9 +0,0 @@
-FROM python:3.11-slim
-
-WORKDIR /app
-COPY . /app
-
-RUN pip install --no-cache-dir -r requirements.txt
-
-EXPOSE 7860
-CMD ["python", "app.py"]

app.py

@@ -1,502 +1,74 @@
+# app.py
 import gradio as gr
-import uuid
-import subprocess
-import time
 import asyncio
 import re
 
-USER_ID = str(uuid.uuid4())
-
-# Iniciar o servidor MCP em background
-mcp_process = subprocess.Popen(
-    ["python", "mcp_server.py"],
-    stdout=subprocess.PIPE,
-    stderr=subprocess.PIPE
-)
-
-time.sleep(3)
-
 from client_agent import stream_agent_response_safe, get_current_chart, PLACEHOLDER_IMAGE
 
-# CSS Profissional
-CUSTOM_CSS = """
-/* Importar fontes profissionais do Google Fonts */
-@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=JetBrains+Mono:wght@400;500&display=swap');
-
-/* Aplicar fonte Inter em todo o app */
-* {
-    font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif !important;
-}
-
-/* Fonte monospace para código */
-code, pre, .message code {
-    font-family: 'JetBrains Mono', 'Courier New', monospace !important;
-}
-
-/* Header principal */
-.gradio-container h1 {
-    font-size: 2.5rem !important;
-    font-weight: 700 !important;
-    background: linear-gradient(135deg, #1e3a8a 0%, #3b82f6 100%);
-    -webkit-background-clip: text;
-    -webkit-text-fill-color: transparent;
-    background-clip: text;
-    margin-bottom: 1rem !important;
-    letter-spacing: -0.02em;
-}
-
-/* Subtítulos */
-.gradio-container h3 {
-    font-size: 1.25rem !important;
-    font-weight: 600 !important;
-    color: #1e293b;
-    margin-bottom: 1rem !important;
-}
-
-/* Descrições */
-.gradio-container p {
-    font-size: 1rem !important;
-    color: #475569;
-    line-height: 1.6;
-}
-
-/* Tabs - Estilo profissional */
-.tabs button {
-    font-size: 1rem !important;
-    font-weight: 600 !important;
-    padding: 0.75rem 1.5rem !important;
-    border-radius: 0.5rem 0.5rem 0 0 !important;
-    transition: all 0.2s ease !important;
-}
-
-.tabs button[aria-selected="true"] {
-    background: linear-gradient(135deg, #1e3a8a 0%, #3b82f6 100%) !important;
-    color: white !important;
-    box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1) !important;
-}
-
-.tabs button:not([aria-selected="true"]) {
-    background: #f1f5f9 !important;
-    color: #64748b !important;
-}
-
-.tabs button:hover:not([aria-selected="true"]) {
-    background: #e2e8f0 !important;
-    color: #334155 !important;
-}
-
-/* Botões principais */
-button[variant="primary"] {
-    background: linear-gradient(135deg, #1e3a8a 0%, #3b82f6 100%) !important;
-    border: none !important;
-    font-weight: 600 !important;
-    font-size: 1rem !important;
-    padding: 0.75rem 1.5rem !important;
-    border-radius: 0.5rem !important;
-    box-shadow: 0 4px 6px -1px rgba(59, 130, 246, 0.3) !important;
-    transition: all 0.3s ease !important;
-}
-
-button[variant="primary"]:hover {
-    transform: translateY(-2px);
-    box-shadow: 0 10px 15px -3px rgba(59, 130, 246, 0.4) !important;
-}
-
-/* Botões secundários */
-button[variant="secondary"] {
-    background: #f8fafc !important;
-    border: 2px solid #cbd5e1 !important;
-    color: #475569 !important;
-    font-weight: 500 !important;
-    border-radius: 0.5rem !important;
-    transition: all 0.2s ease !important;
-}
-
-button[variant="secondary"]:hover {
-    background: #e2e8f0 !important;
-    border-color: #94a3b8 !important;
-}
-
-/* Chatbot - Design limpo e profissional */
-.message-wrap {
-    padding: 1rem !important;
-    margin: 0.5rem 0 !important;
-    border-radius: 0.75rem !important;
-    font-size: 1rem !important;
-    line-height: 1.6 !important;
-}
-
-.message-wrap.user {
-    background: linear-gradient(135deg, #eff6ff 0%, #dbeafe 100%) !important;
-    border-left: 4px solid #3b82f6 !important;
-}
-
-.message-wrap.bot {
-    background: #f8fafc !important;
-    border-left: 4px solid #10b981 !important;
-}
-
-/* Input de texto */
-.gr-textbox textarea {
-    font-size: 1rem !important;
-    padding: 0.875rem !important;
-    border-radius: 0.5rem !important;
-    border: 2px solid #e2e8f0 !important;
-    transition: all 0.2s ease !important;
-}
-
-.gr-textbox textarea:focus {
-    border-color: #3b82f6 !important;
-    box-shadow: 0 0 0 3px rgba(59, 130, 246, 0.1) !important;
-    outline: none !important;
-}
-
-/* Exemplos */
-.examples {
-    border-radius: 0.75rem !important;
-    padding: 1rem !important;
-    background: #f8fafc !important;
-    border: 1px solid #e2e8f0 !important;
-}
-
-.examples button {
-    background: white !important;
-    border: 1px solid #e2e8f0 !important;
-    border-radius: 0.5rem !important;
-    padding: 0.75rem 1rem !important;
-    font-size: 0.95rem !important;
-    color: #475569 !important;
-    transition: all 0.2s ease !important;
-}
-
-.examples button:hover {
-    background: #f1f5f9 !important;
-    border-color: #3b82f6 !important;
-    color: #1e3a8a !important;
-    transform: translateY(-1px);
-}
-
-/* Imagem de visualização */
-.gr-image {
-    border-radius: 0.75rem !important;
-    box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06) !important;
-    border: 1px solid #e2e8f0 !important;
-}
-
-/* Labels */
-label {
-    font-weight: 600 !important;
-    color: #334155 !important;
-    font-size: 0.95rem !important;
-    margin-bottom: 0.5rem !important;
-}
-
-/* Container principal */
-.gradio-container {
-    max-width: 1400px !important;
-    margin: 0 auto !important;
-}
-
-/* Animação suave */
-@keyframes fadeIn {
-    from {
-        opacity: 0;
-        transform: translateY(10px);
-    }
-    to {
-        opacity: 1;
-        transform: translateY(0);
-    }
-}
-
-
-/* Badge de status */
-.status-badge {
-    display: inline-block;
-    padding: 0.25rem 0.75rem;
-    border-radius: 9999px;
-    font-size: 0.875rem;
-    font-weight: 600;
-    background: #dcfce7;
-    color: #166534;
-}
-
-/* Scrollbar personalizada */
-::-webkit-scrollbar {
-    width: 10px;
-}
-
-::-webkit-scrollbar-track {
-    background: #f1f5f9;
-    border-radius: 10px;
-}
-
-::-webkit-scrollbar-thumb {
-    background: #cbd5e1;
-    border-radius: 10px;
-}
-
-::-webkit-scrollbar-thumb:hover {
-    background: #94a3b8;
-}
-"""
+CUSTOM_CSS = """(seu css)"""
 
 async def simulate_streaming_adaptive(full_text: str):
-    """Streaming adaptativo com delays diferentes para pontuação"""
-    words = re.findall(r'\S+\s*', full_text)
-    current_text = ""
-    
-    for word in words:
-        current_text += word
-        
-        if word.strip().endswith(('.', '!', '?')):
-            delay = 0.15
-        elif word.strip().endswith((',', ';', ':')):
-            delay = 0.08
+    words = re.findall(r"\S+|\s+", full_text)
+    current = ""
+    for w in words:
+        current += w
+        if w.strip().endswith((".", "!", "?")):
+            await asyncio.sleep(0.12)
+        elif w.strip().endswith((",", ";", ":")):
+            await asyncio.sleep(0.06)
         else:
-            delay = 0.04
-        
-        await asyncio.sleep(delay)
-        yield current_text
-
-
-# ✅ NATIVE STREAMING DO PYDANTIC AI (prioridade)
-async def respond_native_stream(message, history):
-    """Streaming nativo usando agent.stream_text() - MAIS RÁPIDO e sem tools"""
-    try:
-        print(f"🎯 Native streaming: {message}")
-        
-        history.append(gr.ChatMessage(role="user", content=message))
-        history.append(gr.ChatMessage(role="assistant", content=""))
-        
-        # Tenta streaming nativo SEM tools (mais rápido)
-        async with gr.context():
-            # Aqui você usaria agent.stream_text(message) se disponível
-            # Por enquanto usa o iter() que já funciona
-            async with agent.iter(message, deps=deps) as agent_run:
-                full_text = ""
-                async for node in agent_run:
-                    if hasattr(node, 'text') and node.text:
-                        full_text += node.text
-                        history[-1] = gr.ChatMessage(role="assistant", content=full_text)
-                        yield history, get_current_chart()
-                    elif isinstance(node, End) and agent_run.result:
-                        final_text = str(agent_run.result.output)
-                        history[-1] = gr.ChatMessage(role="assistant", content=final_text)
-                        yield history, get_current_chart()
-                        return
-                        
-    except Exception as e:
-        print(f"❌ Native stream falhou: {e}")
-        # Fallback para streaming simulado
-        yield "Erro. Comunique o desenvolvedor."
-
-# ✅ FALLBACK SIMULADO (só se nativo falhar)
-async def respond_fallback(message, history):
-    """Fallback com streaming simulado adaptativo"""
-    try:
-        print(f"🔄 Fallback streaming: {message}")
-        full_response = await stream_agent_response_safe(message)
-        
-        history.append(gr.ChatMessage(role="user", content=message))
-        history.append(gr.ChatMessage(role="assistant", content=""))
-        
-        async for text_chunk in simulate_streaming_adaptive(full_response):
-            history[-1] = gr.ChatMessage(role="assistant", content=text_chunk)
-            yield history, get_current_chart()
-            
-    except Exception as e:
-        print(f"❌ Fallback falhou: {e}")
-        history.append(gr.ChatMessage(role="user", content=message))
-        history.append(gr.ChatMessage(role="assistant", content=f"⚠️ Erro: {str(e)}"))
-        yield history, get_current_chart()
-
-# ✅ SIMULADOR ADAPTATIVO (melhorado)
-async def simulate_streaming_adaptive(full_response):
-    """Simula streaming inteligente baseado no conteúdo"""
-    if not full_response or len(full_response) < 10:
-        yield full_response
-        return
-    
-    # Velocidades adaptativas por tipo de conteúdo
-    words = full_response.split()
-    if "gráfico" in full_response.lower() or "chart" in full_response.lower():
-        delay = 0.08  # Mais lento para análise visual
-    elif len(words) > 50:
-        delay = 0.06  # Médio para respostas longas
-    else:
-        delay = 0.03  # Rápido para respostas curtas
-    
-    chars_yielded = 0
-    for i in range(0, len(full_response), max(1, len(full_response)//30)):
-        chunk = full_response[chars_yielded:i+1]
-        if chunk:
-            yield chunk
-            chars_yielded = i + 1
-            await asyncio.sleep(delay)
+            await asyncio.sleep(0.02)
+        yield current
 
-# ✅ FUNÇÃO PRINCIPAL SIMPLIFICADA (sem híbrido complexo)
 async def respond(message, history):
-    """Resposta robusta: sempre retorna 2 valores para Gradio"""
     if not message or not message.strip():
         yield history, get_current_chart()
         return
-    
-    print(f"🚀 Processing: {message[:50]}...")
-    
-    # Adiciona mensagem do usuário
-    updated_history = history + [gr.ChatMessage(role="user", content=message)]
-    updated_history.append(gr.ChatMessage(role="assistant", content=""))
-    
+
+    history = history + [gr.ChatMessage(role="user", content=message)]
+    history.append(gr.ChatMessage(role="assistant", content=""))
+
     try:
-        # ✅ Usa a função que JÁ FUNCIONA
         full_response = await stream_agent_response_safe(message)
-        print(f"✅ Resposta completa: {len(full_response)} chars")
-        
-        # Streaming simulado PERFEITO
-        streamed_text = ""
-        async for chunk in simulate_streaming_perfect(full_response):
-            streamed_text += chunk
-            # Atualiza última mensagem do assistente
-            updated_history[-1] = gr.ChatMessage(role="assistant", content=streamed_text)
-            yield updated_history, get_current_chart()
-            
-        # Yield final (Gradio precisa)
-        yield updated_history, get_current_chart()
-        
+        async for partial in simulate_streaming_adaptive(full_response):
+            history[-1] = gr.ChatMessage(role="assistant", content=partial)
+            yield history, get_current_chart()
+        yield history, get_current_chart()
     except Exception as e:
-        print(f"❌ Erro: {e}")
-        import traceback
-        traceback.print_exc()
-        
-        error_msg = f"⚠️ Erro: {str(e)}"
-        updated_history[-1] = gr.ChatMessage(role="assistant", content=error_msg)
-        yield updated_history, get_current_chart()
+        history[-1] = gr.ChatMessage(role="assistant", content=f"⚠️ Error: {e}")
+        yield history, get_current_chart()
 
 def refresh_chart():
-    """Atualiza a visualização do gráfico"""
     return get_current_chart()
 
-# ✅ INTERFACE GRADIO (sem mudanças)
 if __name__ == "__main__":
-    with gr.Blocks(
-        title="Barcelona Analytics Platform",
-        theme=gr.themes.Soft(
-            primary_hue="blue",
-            secondary_hue="slate",
-            neutral_hue="slate",
-            font=[gr.themes.GoogleFont("Inter"), "sans-serif"],
-            font_mono=[gr.themes.GoogleFont("JetBrains Mono"), "monospace"]
-        ),
-        css="""
-        .status-badge { font-size: 0.875rem; color: #64748b; font-style: italic; }
-        .gradio-container { max-width: 1400px !important; }
-        """
-    ) as demo:
-        
-        gr.Markdown(
-            """
-            # 🤖 AI Graph Data Analyst Agent for FC Barcelona
-            """
-        )
-        
-        with gr.Tabs() as tabs:
-            # ABA 1: ANALYSIS & CHAT
-            with gr.Tab("Analysis & Chat", id=0):
-                #gr.Markdown("### Intelligent Assistant *(Streaming Nativo)*")
-                
-                chatbot = gr.Chatbot(
-                    type="messages",
-                    label="",
-                    height=520,
-                    show_copy_button=True,
-                    show_label=False,
-                    avatar_images=["🧠", "⚽"]
-                )
-                
+    with gr.Blocks(title="Barcelona Analytics Platform", css=CUSTOM_CSS) as demo:
+        gr.Markdown("# AI Data Analyst Agent for FC Barcelona")
+
+        with gr.Tabs():
+            with gr.Tab("Analysis & Chat"):
+                chatbot = gr.Chatbot(type="messages", height=520, show_copy_button=True)
                 with gr.Row():
-                    msg = gr.Textbox(
-                        placeholder="Ask about players, matches, or request visualizations... (ex: 'Create bar chart top players')",
-                        label="Your Query",
-                        lines=2,
-                        scale=4,
-                        show_label=False
-                    )
-                    submit_btn = gr.Button("🚀 Analyze", variant="primary", scale=1, size="lg")
-                
-                with gr.Accordion("📋 Query Examples", open=False):
-                    gr.Examples(
-                        examples=[
-                            "List the top 5 players that participated in goals for each season",
-                            "Create a bar chart showing top 5 players with most passes in 2020/2021",
-                            "Show line chart of goal sequences across all seasons",
-                            "Horizontal bar chart: top 10 players by total passes",
-                            "Who passed most frequently to Messi in 2019/2020?"
-                        ],
-                        inputs=msg,
-                        label=""
-                    )
-            
-            # ABA 2: DATA VISUALIZATION
-            with gr.Tab("Data Visualization", id=1):
-                gr.Markdown(
-                    """
-                    ### 📊 Interactive Visualizations
-                    
-                    Charts generated by AI appear **live** here. 
-                    Request in Analysis tab → see results instantly!
-                    """
-                )
-                
+                    msg = gr.Textbox(placeholder="Ask...", lines=2, scale=4, show_label=False)
+                    submit_btn = gr.Button("Send", variant="primary", scale=1)
+
+            with gr.Tab("Data Visualization"):
                 chart_display = gr.Image(
                     value=PLACEHOLDER_IMAGE,
-                    label="",
                     type="pil",
                     height=620,
-                    show_label=False,
                     show_download_button=True,
                     show_share_button=False,
-                    container=True,
-                    interactive=False
+                    show_label=False,
                 )
-                
-                with gr.Row():
-                    refresh_btn = gr.Button("🔄 Refresh Chart", variant="secondary", size="lg")
-                    status = gr.Markdown("_🟢 Live - Updated automatically_", elem_classes="status-badge")
-        
-        # Footer
-        gr.Markdown(
-            """
-            ---
-            **Data:** Neo4j Graph (Barcelona 2016-2021)
-            """
+                refresh_btn = gr.Button("🔄 Refresh Visualization", variant="secondary")
+
+        submit_btn.click(fn=respond, inputs=[msg, chatbot], outputs=[chatbot, chart_display]).then(
+            lambda: "", None, [msg]
         )
-        
-        # 🎯 EVENTOS SIMPLIFICADOS
-        submit_btn.click(
-            fn=respond,
-            inputs=[msg, chatbot],
-            outputs=[chatbot, chart_display]
-        ).then(lambda: "", None, [msg])
-        
-        msg.submit(
-            fn=respond,
-            inputs=[msg, chatbot], 
-            outputs=[chatbot, chart_display]
-        ).then(lambda: "", None, [msg])
-        
-        refresh_btn.click(
-            fn=refresh_chart,
-            outputs=[chart_display]
+        msg.submit(fn=respond, inputs=[msg, chatbot], outputs=[chatbot, chart_display]).then(
+            lambda: "", None, [msg]
         )
-    
-    print("🎯 Barcelona AI Analyst rodando em http://0.0.0.0:7860")
-    
-    demo.launch(
-        ssr_mode=False, 
-        share=False,
-        server_name="0.0.0.0",
-        server_port=7860,
-        show_api=False,
-        favicon_path=None
-    )
+        refresh_btn.click(fn=refresh_chart, inputs=[], outputs=[chart_display])
+
+    demo.launch(ssr_mode=False, share=False)

client_agent.py

@@ -1,154 +1,49 @@
+# client_agent.py
+import os
 import asyncio
+from dataclasses import dataclass
+from dotenv import load_dotenv
+load_dotenv()
+
 from pydantic_ai import Agent, RunContext
-from pydantic_ai.mcp import MCPServerStreamableHTTP
+from pydantic_ai.mcp import MCPServerStdio
 from pydantic_ai.providers.groq import GroqProvider
 from pydantic_ai.models.groq import GroqModel
-from pydantic_ai.messages import PartDeltaEvent, TextPartDelta
 from pydantic_graph import End
+
 from tools.searching import SearchingTools
 
 import pandas as pd
 from typing import List, Dict, Any, Optional
-
 import matplotlib
-matplotlib.use('Agg')
+matplotlib.use("Agg")
 import matplotlib.pyplot as plt
 import io
 from PIL import Image, ImageDraw, ImageFont
 
-
-from dataclasses import dataclass
-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 five seasons - from 2016/2017 to 2020/2021.
-Use the tools available to respond the user query. You are connected to neo4j by a MCP server created by Frederico Caixeta.
-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. Limit your answer in **1500** characters.
-When the user asks for visualizations, graphs, or charts, you MUST use the create_chart tool 
-to generate the appropriate visualization. The chart will be displayed in the Visualization tab.
-# 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.
-The seasons ids and their dates: [{90: '2020/2021'}, {42: '2019/2020'}, {4: '2018/2019'}, {1: '2017/2018'}, {2: '2016/2017'}]
-# 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
-"""
-
-
-
+SYSTEM_PROMPT = """(seu prompt grande aqui)"""
 
 api_key = os.getenv("GROQ_DEV_API_KEY")
 groq_model = GroqModel(
-    "moonshotai/kimi-k2-instruct-0905",
-    provider=GroqProvider(api_key=api_key)
+    "llama-3.1-70b-versatile",
+    provider=GroqProvider(api_key=api_key),
+)
+
+# ✅ MCP via stdio (subprocess) — ideal no Hugging Face
+neo4j_server = MCPServerStdio(
+    "python",
+    args=["mcp_server.py"],
+    tool_prefix="neo4j",  # ex: neo4j_execute_cypher_query
+    timeout=30,
 )
 
 @dataclass
 class SearchAgentDeps:
     tools: SearchingTools
-    
-# Criar agent com o servidor MCP
+
 agent = Agent(
     model=groq_model,
-    toolsets=[neo4j_server],
+    toolsets=[neo4j_server],     # ✅ server MCP anexado
     system_prompt=SYSTEM_PROMPT,
     deps_type=SearchAgentDeps,
 )
@@ -156,52 +51,32 @@ agent = Agent(
 tools_instance = SearchingTools()
 deps = SearchAgentDeps(tools=tools_instance)
 
-@agent.tool(name="web_search",retries=3)
+@agent.tool(name="web_search", retries=3)
 async 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
-    )
+    return ctx.deps.tools.search_web(search_query=search_query, max_results=15)
 
-# ============= NOVA FUNCIONALIDADE: VISUALIZAÇÕES =============
-
-# Variável global para armazenar o último gráfico
 last_chart_image = None
 
 def create_placeholder_image():
-    """Cria uma imagem placeholder simples com texto"""
-    # Cores profissionais
-    bg_color = (248, 250, 252)  # Slate-50
-    text_color = (100, 116, 139)  # Slate-500
-    
-    img = Image.new('RGB', (800, 600), color=bg_color)
+    bg_color = (248, 250, 252)
+    text_color = (100, 116, 139)
+    img = Image.new("RGB", (800, 600), color=bg_color)
     draw = ImageDraw.Draw(img)
-    
-    # Carregar fonte
     try:
         font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 48)
-    except:
+    except Exception:
         font = ImageFont.load_default()
-    
-    # Texto centralizado
     text = "Waiting for plot..."
     bbox = draw.textbbox((0, 0), text, font=font)
-    text_width = bbox[2] - bbox[0]
-    text_height = bbox[3] - bbox[1]
-    
-    x = (800 - text_width) // 2
-    y = (600 - text_height) // 2
-    
+    x = (800 - (bbox[2] - bbox[0])) // 2
+    y = (600 - (bbox[3] - bbox[1])) // 2
     draw.text((x, y), text, fill=text_color, font=font)
-    
     return img
 
-
-
 PLACEHOLDER_IMAGE = create_placeholder_image()
 
-@agent.tool(name="create_chart", retries=2)
+@agent.tool(name="create_chart", retries=2, timeout=30.0)
 async def create_chart(
     ctx: RunContext[SearchAgentDeps],
     data: List[Dict[str, Any]],
@@ -212,100 +87,56 @@ async def create_chart(
     x_title: Optional[str] = None,
     y_title: Optional[str] = None,
 ) -> str:
-    """
-    Cria uma visualização dos dados.
-    
-    Args:
-        data: Lista de dicionários com os dados
-        x_column: Coluna do eixo X
-        y_column: Coluna do eixo Y
-        chart_type: Tipo ('bar', 'line', 'scatter', 'horizontal_bar')
-        title: Título do gráfico
-        x_title: Título do eixo X
-        y_title: Título do eixo Y
-    """
     global last_chart_image
-    
     try:
         df = pd.DataFrame(data)
-        
         if x_column not in df.columns or y_column not in df.columns:
             return f"❌ Erro: Colunas não encontradas. Disponíveis: {list(df.columns)}"
-        
+
         fig, ax = plt.subplots(figsize=(10, 6))
-        
+
         if chart_type == "bar":
-            bars = ax.bar(df[x_column], df[y_column], color='#4682B4', 
-                         edgecolor='#2F4F7F', linewidth=1.5)
-            for bar in bars:
-                height = bar.get_height()
-                ax.text(bar.get_x() + bar.get_width()/2., height,
-                       f'{height:.0f}', ha='center', va='bottom', fontsize=9)
-                       
+            ax.bar(df[x_column], df[y_column])
         elif chart_type == "horizontal_bar":
-            ax.barh(df[x_column], df[y_column], color='#4682B4', 
-                   edgecolor='#2F4F7F', linewidth=1.5)
-                   
+            ax.barh(df[x_column], df[y_column])
         elif chart_type == "line":
-            ax.plot(df[x_column], df[y_column], marker='o', linewidth=2.5, 
-                   markersize=8, color='#4682B4', markerfacecolor='#FF6B6B')
-            ax.grid(True, alpha=0.3, linestyle='--')
-            
+            ax.plot(df[x_column], df[y_column], marker="o")
         elif chart_type == "scatter":
-            ax.scatter(df[x_column], df[y_column], s=100, alpha=0.6, 
-                      color='#4682B4', edgecolors='#2F4F7F', linewidth=1.5)
-            ax.grid(True, alpha=0.3, linestyle='--')
+            ax.scatter(df[x_column], df[y_column])
         else:
             return f"❌ Tipo '{chart_type}' não suportado"
-        
-        ax.set_title(title or f"{y_column} por {x_column}", 
-                    fontsize=16, fontweight='bold', pad=20)
-        ax.set_xlabel(x_title or x_column, fontsize=12, fontweight='bold')
-        ax.set_ylabel(y_title or y_column, fontsize=12, fontweight='bold')
-        
-        if chart_type != "horizontal_bar":
-            plt.xticks(rotation=45, ha='right')
-        
-        ax.set_axisbelow(True)
-        ax.yaxis.grid(True, alpha=0.3, linestyle='--')
+
+        ax.set_title(title or f"{y_column} por {x_column}")
+        ax.set_xlabel(x_title or x_column)
+        ax.set_ylabel(y_title or y_column)
         plt.tight_layout()
-        
-        # Salvar imagem
+
         buf = io.BytesIO()
-        plt.savefig(buf, format='png', dpi=150, bbox_inches='tight', 
-                   facecolor='white')
+        plt.savefig(buf, format="png", dpi=150, bbox_inches="tight", facecolor="white")
         buf.seek(0)
         last_chart_image = Image.open(buf).copy()
         plt.close()
-        
-        return f"✅ Gráfico de **{chart_type}** criado! {len(df)} registros. Confira na aba **Visualização** 📊"
-        
+
+        return f"✅ Gráfico '{chart_type}' criado ({len(df)} registros)."
     except Exception as e:
         return f"❌ Erro ao criar gráfico: {str(e)}"
 
 def get_current_chart():
-    """Retorna o gráfico atual ou placeholder"""
     global last_chart_image
     return last_chart_image if last_chart_image is not None else PLACEHOLDER_IMAGE
 
-
 async def stream_agent_response_safe(user_query: str) -> str:
-    """
-    Executa o agente e retorna apenas a resposta final completa.
-    """
+    # ✅ manter iter() que já funciona
     async with agent.iter(user_query, deps=deps) as agent_run:
         async for node in agent_run:
-            if isinstance(node, End):
-                if agent_run.result:
-                    return str(agent_run.result.output)
+            if isinstance(node, End) and agent_run.result:
+                return str(agent_run.result.output)
     return "Erro na execução do agente"
 
-if __name__ == '__main__':
-    async def test_safe():
-        print("=== Teste stream_agent_response_safe ===")
-        response = await stream_agent_response_safe(
-            "List the 5 top players that participated in goals, each season"
-        )
-        print(response)
-    
-    asyncio.run(test_safe())
+__all__ = [
+    "agent",
+    "deps",
+    "PLACEHOLDER_IMAGE",
+    "get_current_chart",
+    "stream_agent_response_safe",
+]

mcp_server.py

@@ -1,194 +1,77 @@
+# mcp_server.py
 import os
-from typing import Optional, List, Dict, Any
+from typing import Optional, Dict, Any
 from dotenv import load_dotenv
 from neo4j import GraphDatabase
-from mcp.server.fastmcp import FastMCP, Context
-#
-# Carregar variáveis de ambiente
+from mcp.server.fastmcp import FastMCP
+
 load_dotenv()
 
-# Configuração do Neo4j
 NEO4J_URI: str = os.getenv("NEO4J_URI", "")
 NEO4J_USER = os.getenv("NEO4J_USER")
 NEO4J_PASSWORD = os.getenv("NEO4J_PASSWORD")
 
 assert NEO4J_URI, "NEO4J_URI deve ser fornecida (não pode ser None ou vazia)"
-# Criar conexão global Neo4j
+
 class Neo4jConnection:
     def __init__(self):
         self.driver = GraphDatabase.driver(
-            NEO4J_URI, 
-            auth=(NEO4J_USER, NEO4J_PASSWORD)
+            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):
+def _ensure_read_only(query: str) -> Optional[str]:
+    q = query.upper().strip()
+    dangerous = ["DELETE", "DETACH", "REMOVE", "SET", "CREATE", "MERGE", "DROP", "CALL"]
+    if any(k in q for k in dangerous):
         return "❌ ERRO: Apenas queries de leitura (MATCH/RETURN) são permitidas."
-    
+    return None
+
+@mcp.tool()
+def execute_cypher_query(query: str, parameters: Optional[Dict[str, Any]] = None, limit: int = 100) -> str:
+    """Executa uma query Cypher READ-ONLY no Neo4j (MATCH/RETURN)."""
+    err = _ensure_read_only(query)
+    if err:
+        return err
+
     try:
-        # Adicionar LIMIT se não existir
-        if 'LIMIT' not in query_upper:
-            query += f" LIMIT {limit}"
-        
+        q_upper = query.upper()
+        if "LIMIT" not in q_upper:
+            query = f"{query}\nLIMIT {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"]
-        
+
+        out = [f"📊 Resultados ({len(results)} encontrados):"]
         for i, record in enumerate(results[:10], 1):
             items = [f"{k}={v}" for k, v in record.items()]
-            output.append(f"{i}. {', '.join(items)}")
-        
+            out.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()
-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)}"
+            out.append(f"... e mais {len(results) - 10} resultados.")
 
-# 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)
-        
+        return "\n".join(out)
     except Exception as e:
-        return f"❌ Erro: {str(e)}"
+        return f"❌ Erro ao executar query: {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
-    """
+def player_efficiency(player_name: str) -> str:
+    """Eficiência: passes totais vs passes em sequências de gol."""
     query = """
     MATCH (p:Player {name: $player_name})
     OPTIONAL MATCH (p)-[total:PASSED_TO]->()
@@ -199,84 +82,59 @@ async def player_efficiency(player_name: str) -> str:
     RETURN p.name as Player,
            TotalPasses,
            PassesInGoals,
-           CASE 
-               WHEN TotalPasses > 0 
-               THEN round(PassesInGoals * 100.0 / TotalPasses, 2)
-               ELSE 0
+           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']:
+        if not results or results[0].get("TotalPasses") is None:
             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)
-        
+        return "\n".join(
+            [
+                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']}%",
+            ]
+        )
     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ć
-    """
+def rakitic_goal_statistics() -> str:
+    """Estatísticas de Ivan Rakitić em sequências de gol."""
     query = """
     MATCH (rak:Player {name: "Ivan Rakitić"})-[r:PASSED_IN_SEQUENCE]->(receiver:Player)
-    WITH rak, receiver, r, r.sequence_id as seqId
+    WITH 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
+           round(avg(r.order), 2) as AvgPassPosition
     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']})"
+
+        lines = ["⭐ Estatísticas de Ivan Rakitić em Sequências de Gol:"]
+        for i, r in enumerate(results, 1):
+            lines.append(
+                f"{i}. {r['PassedTo']}: {r['NumberOfGoalSequences']} sequências (posição média: {r['AvgPassPosition']})"
             )
-        
-        return "\n".join(output)
-        
+        return "\n".join(lines)
     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())
+if __name__ == "__main__":
+    try:
+        # ✅ Padrão dos docs: stdio
+        mcp.run()
+    finally:
+        neo4j.close()

requirements.txt

@@ -3,4 +3,6 @@ tavily-python==0.7.12
 neo4j==6.0.2
 matplotlib==3.10.7
 pandas==2.3.3
-mcp==1.25.0
+mcp==1.25.0
+python-dotenv
+pillow