SQLLLLLLLLLL

.gitignore

@@ -0,0 +1,10 @@
+#gitignore
+__pycache__/
+*.pyc
+.env
+.vscode/
+instance/
+.python-version
+.logfire
+#duckdb
+*.duckdb

app.py

@@ -1,70 +1,215 @@
 import gradio as gr
-from huggingface_hub import InferenceClient
+import uuid
+import subprocess
+import time
+import asyncio
+import re
 
+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")
+# Iniciar o servidor MCP em background
+# subprocess.Popen(["python", "mcp_players_table_sql.py"])  
+# subprocess.Popen(["python", "mcp_team_table_sql.py"])     
+subprocess.Popen(["python", "mcp_one_player_supabase.py"])     
+time.sleep(3)
+# subprocess.Popen(["python", "mcp_graph_server.py"])   
+# time.sleep(3)
 
-    messages = [{"role": "system", "content": system_message}]
+#from place_holder_image import PLACEHOLDER_IMAGE, get_current_chart
+from main_agent import stream_agent_response_safe, PLACEHOLDER_IMAGE, get_current_chart, agent_conventional_response
+from utils import CUSTOM_CSS
 
-    messages.extend(history)
+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
+        else:
+            delay = 0.04
+        
+        await asyncio.sleep(delay)
+        yield current_text
 
-    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)",
-        ),
-    ],
-)
-
-with gr.Blocks() as demo:
-    with gr.Sidebar():
-        gr.LoginButton()
-    chatbot.render()
+async def respond(message, history):
+    """Função de resposta com streaming + atualização de gráfico"""
+    message = str(message)
+    print(f"Message received: {message}")
+    
+    try:
+        print("Obtendo resposta completa do agente...")
+        full_response = await stream_agent_response_safe(message)
+        print(f"Resposta obtida: {len(full_response)} caracteres")
+        
+        # Simular streaming da resposta
+        async for text_chunk in simulate_streaming_adaptive(full_response):
+            yield text_chunk, get_current_chart()
+            
+    except Exception as e:
+        print(f"Erro durante o processamento: {e}")
+        import traceback
+        traceback.print_exc()
+        yield f"❌ Erro: {str(e)}", get_current_chart()
 
+def refresh_chart():
+    """Atualiza a visualização do gráfico"""
+    return get_current_chart()
 
 if __name__ == "__main__":
-    demo.launch()
+    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=CUSTOM_CSS
+    ) as demo:
+        
+        gr.Markdown(
+            """
+            #### Data Analyst Agent with FC Barcelona Statistics (2020/2021)
+            
+            Powered by Postgres (Supabase) via MCP.
+            """
+        )
+        
+        with gr.Tabs() as tabs:
+            # ABA 1: ANALYSIS & CHAT
+            with gr.Tab("Chat", id=0):
+                #gr.Markdown("### Intelligent Assistant")
+                
+                chatbot = gr.Chatbot(
+                    type="messages",
+                    label="",
+                    height=330,
+                    show_copy_button=True
+                )
+                
+                with gr.Row():
+                    msg = gr.Textbox(
+                        placeholder="Ask about players, matches, or request visualizations...",
+                        label="Your Query",
+                        lines=2,
+                        scale=4,
+                        show_label=False
+                    )
+                    submit_btn = gr.Button("Send", variant="primary", scale=1, size="lg")
+                
+                with gr.Accordion("📋 Query Examples", open=False):
+                    gr.Examples(
+                        examples=[
+                            "Return the top 10 players by total xG and assists combined",
+                            "Create a bar chart showing the top 5 players with most passes",
+                            "Find players with at least 900 minutes who rank in the top 5% for progressive passes and top 10% for xG assisted in 2020/2021, returning player, minutes, prog_passes, xA, and z-scores"
+                        ],
+                        inputs=msg,
+                        label=""
+                    )
+            
+            # ABA 2: DATA VISUALIZATION
+            with gr.Tab("Data Visualization", id=1):
+                gr.Markdown(
+                    """
+                    ### Interactive Visualizations
+                    
+                    Charts and graphs generated by the AI assistant will appear here. 
+                    Request visualizations in the Analysis tab to see them rendered.
+                    """
+                )
+                
+                chart_display = gr.Image(
+                    value=PLACEHOLDER_IMAGE,
+                    label="",
+                    type="pil",
+                    height=330,
+                    show_label=False,
+                    show_download_button=True,
+                    show_share_button=False
+                )
+                
+                with gr.Row():
+                    refresh_btn = gr.Button("🔄 Refresh Visualization", variant="secondary", size="lg")
+                    gr.Markdown("_Last updated: Live_", elem_classes="status-badge")
+        
+        # Footer informativo
+        gr.Markdown(
+            """
+            ---
+            **Data Source:** SQL Database • **AI Model:** Groq-powered Analysis • **Coverage:** 1 Seasons (2020-2021)
+            """
+        )
+        
+        async def respond_and_update(message, history):
+            """Responde e retorna tanto o chat quanto o gráfico atualizado"""
+            if not message.strip():
+                yield history, get_current_chart()
+                return
+            
+            # Adicionar mensagem do usuário
+            history.append(gr.ChatMessage(role="user", content=message))
+            
+            try:
+                # Obter resposta
+                # full_response = await asyncio.wait_for(
+                #     stream_agent_response_safe(message),
+                #     timeout=120.0
+                # )
+                
+                full_response = await agent_conventional_response(message)
+                
+                # Adicionar mensagem inicial do assistente
+                history.append(gr.ChatMessage(role="assistant", content=""))
+                
+                # Streaming adaptativo
+                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 asyncio.TimeoutError:
+                history.append([message, "⏱️ Timeout: consulta demorou muito"])
+                yield history, get_current_chart()
+                
+            except Exception as e:
+                print(f"Erro: {e}")
+                import traceback
+                traceback.print_exc()
+                history.append(gr.ChatMessage(role="assistant", content=f"⚠️ Error: {str(e)}"))
+                yield history, get_current_chart()
+        
+        # Eventos
+        submit_btn.click(
+            fn=respond_and_update,
+            inputs=[msg, chatbot],
+            outputs=[chatbot, chart_display]
+        ).then(
+            lambda: "",
+            None,
+            [msg]
+        )
+        
+        msg.submit(
+            fn=respond_and_update,
+            inputs=[msg, chatbot],
+            outputs=[chatbot, chart_display]
+        ).then(
+            lambda: "",
+            None,
+            [msg]
+        )
+        
+        refresh_btn.click(
+            fn=refresh_chart,
+            inputs=[],
+            outputs=[chart_display]
+        )
+    
+    demo.launch(ssr_mode=False, share=False)

main.py

@@ -0,0 +1,6 @@
+def main():
+    print("Hello from barcelona-ai-agent-stats!")
+
+
+if __name__ == "__main__":
+    main()

main_agent.py

@@ -0,0 +1,341 @@
+import asyncio
+from pydantic_ai import Agent, RunContext
+from pydantic_ai.mcp import MCPServerStreamableHTTP
+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
+
+# import logfire
+# logfire.configure()  
+# logfire.instrument_pydantic_ai() 
+
+
+#PROMPTS
+from prompts import matches_prompt, players_prompt, player_matchid_prompt, graph_agent_prompt
+MATCHES_SYSTEM_PROMPT = matches_prompt.MATCHES_SYSTEM_PROMPT
+PLAYERS_SYSTEM_PROMPT = players_prompt.PLAYERS_SYSTEM_PROMPT
+PLAYER_MATCHID_SYSTEM_PROMPT = player_matchid_prompt.SYSTEM_PROMPT
+GRAPH_AGENT_PROMPT = graph_agent_prompt.GRAPH_AGENT_SYSTEM_PROMPT
+
+import pandas as pd
+from typing import List, Dict, Any, Optional
+
+import matplotlib
+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
+mcp_players_server = MCPServerStreamableHTTP(
+    url = "http://127.0.0.1:8001/mcp"
+)
+
+mcp_one_player = MCPServerStreamableHTTP(
+    url = "http://127.0.0.1:8003/mcp"
+)
+
+mcp_matches_server = MCPServerStreamableHTTP(
+    url = "http://127.0.0.1:8002/mcp"
+)
+
+mcp_graph_server = MCPServerStreamableHTTP(
+    url = "http://127.0.0.1:8004/mcp"
+)
+
+ROUTER_SYSTEM_PROMPT = """
+# You are an Expert Football Analyst with access to Barcelona match statistics from season 2020/2021.
+You are connected to 2 agents connected to tools - one that can retrieve match statistics, one that can provide player match-level statistics based on match IDs.
+Use both agents to answer user queries as needed.
+Return to the user properly in a professional manner. Limit your answers to 1500 characters.
+"""
+from pydantic import BaseModel
+from pydantic_ai import Agent, RunContext
+class Deps(BaseModel):
+    ai_query: str
+
+api_key = os.getenv("GROQ_DEV_API_KEY")
+groq_model = GroqModel(
+    "moonshotai/kimi-k2-instruct-0905",
+    provider=GroqProvider(api_key=api_key)
+)
+
+api_key_2 = os.getenv("GROQ_DEV_API_KEY_2")
+groq_model_2 = GroqModel(
+    "openai/gpt-oss-20b",
+    provider=GroqProvider(api_key=api_key_2)
+)
+
+main_agent = Agent(
+    model=groq_model_2,
+    system_prompt=ROUTER_SYSTEM_PROMPT,
+    deps_type=Deps,
+)
+
+matches_agent = Agent(
+        model=groq_model,
+        system_prompt=ROUTER_SYSTEM_PROMPT,
+        toolsets=[mcp_matches_server]
+    )
+
+players_agent = Agent(
+        model=groq_model_2,
+        system_prompt=ROUTER_SYSTEM_PROMPT,
+        toolsets=[mcp_players_server]
+    )
+
+one_player_agent = Agent(
+        model=groq_model,
+        system_prompt=PLAYER_MATCHID_SYSTEM_PROMPT,
+        toolsets=[mcp_one_player]
+    )
+
+graph_agent = Agent(
+        model=groq_model_2,
+        system_prompt=GRAPH_AGENT_PROMPT,
+        toolsets=[mcp_graph_server]
+    )
+
+# ============= 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)
+    draw = ImageDraw.Draw(img)
+    
+    # Carregar fonte
+    try:
+        font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 48)
+    except:
+        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
+    
+    draw.text((x, y), text, fill=text_color, font=font)
+    
+    return img
+
+last_chart_image = None
+PLACEHOLDER_IMAGE = create_placeholder_image()
+
+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
+
+
+@main_agent.tool(name="get_matches_stats", description="Use this tool to get match-level statistics for FC Barcelona matches.")
+async def get_matches_stats(ctx: RunContext[Deps], request_for_agent: str, retries=0) -> str:
+    print("Getting matches stats...")
+    async with asyncio.timeout(60):
+        resp = await matches_agent.run(request_for_agent)
+        return resp.output
+
+@main_agent.tool(name="get_players_stats", description="Get overall statistics of players.", retries=0)
+async def get_players_stats(ctx: RunContext[Deps], request_for_agent: str) -> str:
+    print("Getting players stats...")
+    async with asyncio.timeout(60):
+        resp = await players_agent.run(request_for_agent)
+        return resp.output
+    
+@main_agent.tool(name="get_one_player_stats", description="Use this tool to get match-level statistics for a specific Barcelona player based on match IDs.")
+async def get_one_player_stats(ctx: RunContext[Deps], request_for_agent: str, retries=0) -> str:
+    print("Getting one player stats...")
+    async with asyncio.timeout(60):
+        resp = await one_player_agent.run(request_for_agent)
+        return resp.output
+
+# @one_player_agent.tool(name="get_graph_passes_infomation", description="Get Deep Graph Passes information from specialized Agent.")
+# async def get_graph_passes_infomation(ctx: RunContext[Deps], query: str) -> str:
+#     print("Getting passes information...")
+#     resp = await graph_agent.run(query)
+#     return resp.output
+
+# @one_player_agent.tool(
+#     name="get_graph_passes_infomation",
+#     description="Get Deep Graph Passes information from specialized Agent."
+# )
+# async def get_graph_passes_infomation(ctx: RunContext[Deps], query: str) -> str:
+#     """
+#     ⚠️ CRÍTICO: Não use agent.run() dentro de agent.iter()!
+#     Isso causa nested cancel scopes.
+    
+#     Solução: Use run_sync() ou conecte diretamente ao MCP.
+#     """
+#     try:
+#         # ✅ Opção 1: Use run_sync para evitar nesting
+#         import asyncio
+#         result = await asyncio.to_thread(
+#             lambda: asyncio.run(graph_agent.run(query))
+#         )
+#         return result.output
+        
+#     except Exception as e:
+#         return f"❌ Erro ao acessar graph agent: {str(e)}"
+
+@one_player_agent.tool(name="create_chart", retries=2)
+async def create_chart(
+    ctx: RunContext[Deps],
+    data: List[Dict[str, Any]],
+    x_column: str,
+    y_column: str,
+    chart_type: str = "bar",
+    title: Optional[str] = None,
+    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)
+                       
+        elif chart_type == "horizontal_bar":
+            ax.barh(df[x_column], df[y_column], color='#4682B4', 
+                   edgecolor='#2F4F7F', linewidth=1.5)
+                   
+        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='--')
+            
+        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='--')
+        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='--')
+        plt.tight_layout()
+        
+        # Salvar imagem
+        buf = io.BytesIO()
+        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** 📊"
+        
+    except Exception as e:
+        return f"❌ Erro ao criar gráfico: {str(e)}"
+
+# async def stream_agent_response_safe(user_query: str) -> str:
+#     """
+#     Versão mais segura que sempre retorna a resposta completa ao final.
+#     Ideal para garantir que APENAS a resposta final seja exibida.
+    
+#     Args:
+#         user_query: A query do usuário
+        
+#     Yields:
+#         str: Resposta final completa (após processamento de todas as tools)
+#     """
+
+#     async with one_player_agent.iter(user_query) as agent_run:
+#         async for node in agent_run:
+#             if isinstance(node, End):
+#                 if agent_run.result:
+#                     return str(agent_run.result.output)
+
+async def agent_conventional_response(user_query: str) -> str:
+    final_response = None
+    res = await one_player_agent.run(user_prompt=user_query)
+    final_response = res.output
+    return final_response
+       
+async def stream_agent_response_safe(user_query: str) -> str:
+    """
+    Executa o agente com proteção contra cancelamento
+    """
+    final_response = None
+    
+    try:
+        async with one_player_agent.iter(user_query) as agent_run:
+            async for node in agent_run:
+                if isinstance(node, End):
+                    if agent_run.result:
+                        final_response = str(agent_run.result.output)
+                        break
+                        
+    except asyncio.CancelledError:
+        # Permite que o MCP client feche gracefully
+        print("⚠️ Agente cancelado - aguardando cleanup do MCP...")
+        await asyncio.sleep(0.5)  # Dá tempo para cleanup
+        raise
+        
+    except Exception as e:
+        print(f"❌ Erro no agente: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        return f"Erro ao processar: {str(e)}"
+    
+    return final_response if final_response else "Nenhuma resposta gerada"
+
+       
+# Teste
+async def test_safe():
+    async with one_player_agent:
+        result = await one_player_agent.run("Which player has most yellow cards per time played - cards/min? Answer in cards per minute.")
+        print(result.output)
+
+
+if __name__ == "__main__":
+    asyncio.run(test_safe())

mcp_one_player_supabase.py

@@ -0,0 +1,264 @@
+import os
+import sys
+import asyncio
+import signal
+from typing import Optional
+from functools import partial
+
+from dotenv import load_dotenv
+from psycopg2 import pool
+from psycopg2.extras import RealDictCursor
+
+from mcp.server.fastmcp import FastMCP
+
+# =========================
+# .env
+# =========================
+load_dotenv()
+
+
+SUPABASE_DB_URI = os.getenv("SUPABASE_DB_URI")
+
+DEFAULT_PORT = int(os.getenv("DEFAULT_PORT", "8003"))
+
+if "YOUR_PASSWORD" in SUPABASE_DB_URI:
+    print("❌ ERRO: Defina SUPABASE_DB_URI com sua senha real.")
+    sys.exit(1)
+
+# =========================
+# Conexão Supabase (URI + SSL)
+# =========================
+class SupabaseConnection:
+    def __init__(self, dsn: str):
+        try:
+            self.pool = pool.ThreadedConnectionPool(
+                minconn=1,
+                maxconn=10,
+                dsn=dsn
+            )
+            print("✓ Pool criado")
+
+            conn = self.pool.getconn()
+            try:
+                with conn.cursor() as cur:
+                    cur.execute("SELECT current_database(), inet_server_addr(), inet_server_port();")
+                    db, ip, port = cur.fetchone()
+                    print(f"✓ Conexão OK: db={db}, ip={ip}, port={port}")
+            finally:
+                self.pool.putconn(conn)
+
+        except Exception as e:
+            print("❌ Falha na conexão:", e)
+            sys.exit(1)
+
+    async def execute_query_async(self, query: str, parameters: Optional[tuple] = None):
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(None, partial(self._execute_query_sync, query, parameters))
+
+    def _execute_query_sync(self, query: str, parameters: Optional[tuple] = None):
+        conn = None
+        try:
+            conn = self.pool.getconn()
+            conn.autocommit = True
+            with conn.cursor(cursor_factory=RealDictCursor) as cur:
+                if parameters:
+                    cur.execute(query, parameters)
+                else:
+                    cur.execute(query)
+                if cur.description:
+                    return [dict(r) for r in cur.fetchall()]
+                return []
+        except Exception as e:
+            raise Exception(f"Erro ao executar query: {str(e)}")
+        finally:
+            if conn:
+                self.pool.putconn(conn)
+
+    def close(self):
+        if hasattr(self, 'pool') and self.pool:
+            self.pool.closeall()
+            print("✓ Pool fechado")
+
+db = SupabaseConnection(SUPABASE_DB_URI)
+
+# =========================
+# MCP Server
+# =========================
+mcp = FastMCP(name="Football Player Match Analytics - Supabase", port=str(DEFAULT_PORT))
+
+@mcp.tool()
+async def execute_sql_query(query: str, limit: int = 100) -> str:
+    """
+    Executa query SQL READ-ONLY.
+    """
+    query_upper = query.upper().strip()
+    dangerous = ['DELETE', 'DROP', 'INSERT', 'UPDATE', 'ALTER', 'CREATE', 'TRUNCATE']
+    if any(k in query_upper for k in dangerous):
+        return "❌ ERRO: Apenas queries de leitura (SELECT) são permitidas."
+    try:
+        if 'LIMIT' not in query_upper:
+            query += f" LIMIT {limit}"
+        results = await db.execute_query_async(query)
+        if not results:
+            return "✓ Query executada, mas nenhum resultado encontrado."
+        lines = [f"📊 Resultados ({len(results)} registros):\n"]
+        for i, record in enumerate(results[:10], 1):
+            items = [f"{k}={v}" for k, v in record.items()]
+            lines.append(f"{i}. {', '.join(items)}")
+        if len(results) > 10:
+            lines.append(f"\n... e mais {len(results) - 10} resultados.")
+        return "\n".join(lines)
+    except Exception as e:
+        return f"❌ Erro: {str(e)}"
+
+@mcp.tool()
+async def get_player_match_history(player_name: str, limit: int = 10) -> str:
+    query = """
+        SELECT 
+            match_date, opponent, home_away, minutes_played,
+            goals, assists, shots, xg, pass_completion_pct, player_nickname
+        FROM player_match_stats
+        WHERE player_nickname ILIKE %s
+        ORDER BY match_date DESC
+        LIMIT %s
+    """
+    try:
+        results = await db.execute_query_async(query, (f'%{player_name}%', limit))
+        if not results:
+            return f"❌ Nenhum dado encontrado para '{player_name}'"
+        out = [f"📊 HISTÓRICO DE PARTIDAS - {player_name.upper()}\n"]
+        for r in results:
+            xg = f"{(r.get('xg') or 0):.2f}"
+            pcp = f"{(r.get('pass_completion_pct') or 0):.1f}"
+            out.append(
+                f"📅 {r['match_date']} vs {r['opponent']} ({r['home_away']}) - "
+                f"{r['minutes_played']}min | "
+                f"⚽ {r['goals']} gols, 🤝 {r['assists']} assists | "
+                f"🎯 {r['shots']} chutes (xG: {xg}) | "
+                f"📈 {pcp}% passes"
+            )
+        return "\n".join(out)
+    except Exception as e:
+        return f"❌ Erro: {str(e)}"
+
+@mcp.tool()
+async def get_match_performances(match_date: Optional[str] = None, opponent: Optional[str] = None, limit: int = 15) -> str:
+    if not match_date and not opponent:
+        return "❌ Forneça match_date OU opponent"
+    where_clauses, params = [], []
+    if match_date:
+        where_clauses.append("match_date = %s")
+        params.append(match_date)
+    if opponent:
+        where_clauses.append("opponent ILIKE %s")
+        params.append(f'%{opponent}%')
+    where_sql = " AND ".join(where_clauses)
+    params.append(limit)
+    query = f"""
+        SELECT 
+            player_nickname, minutes_played, goals, assists,
+            (goals + assists) as contributions, shots, xg,
+            pass_completion_pct, touches
+        FROM player_match_stats
+        WHERE {where_sql}
+        ORDER BY (goals + assists) DESC, xg DESC
+        LIMIT %s
+    """
+    try:
+        results = await db.execute_query_async(query, tuple(params))
+        if not results:
+            return "❌ Partida não encontrada"
+        info = f"{match_date or 'Data'} vs {opponent or 'Adversário'}"
+        out = [f"🏟️ PERFORMANCES - {info}\n"]
+        for i, r in enumerate(results, 1):
+            xg = f"{(r.get('xg') or 0):.2f}"
+            pcp = f"{(r.get('pass_completion_pct') or 0):.1f}"
+            touches = r.get('touches', 0)
+            out.append(
+                f"{i}. {r['player_nickname']} ({r['minutes_played']}min): "
+                f"⚽ {r['goals']}G + 🤝 {r['assists']}A = {r['contributions']} contrib. | "
+                f"🎯 {r['shots']} chutes (xG: {xg}) | "
+                f"📈 {pcp}% passes | "
+                f"👟 {touches} toques"
+            )
+        return "\n".join(out)
+    except Exception as e:
+        return f"❌ Erro: {str(e)}"
+
+@mcp.tool()
+async def get_top_performances(metric: str = "goals", limit: int = 10) -> str:
+    valid = {
+        "goals": ("goals", "Gols"),
+        "assists": ("assists", "Assistências"),
+        "contributions": ("goals + assists", "Contribuições"),
+        "xg": ("xg", "xG"),
+        "shots": ("shots", "Finalizações")
+    }
+    if metric not in valid:
+        return f"❌ Métrica inválida. Opções: {', '.join(valid.keys())}"
+    metric_sql, metric_name = valid[metric]
+    query = f"""
+        SELECT 
+            player_nickname, match_date, opponent, home_away,
+            goals, assists, xg, shots, pass_completion_pct
+        FROM player_match_stats
+        ORDER BY {metric_sql} DESC
+        LIMIT %s
+    """
+    try:
+        results = await db.execute_query_async(query, (limit,))
+        if not results:
+            return "❌ Nenhum dado encontrado"
+        out = [f"🏆 TOP {len(results)} PERFORMANCES - {metric_name.upper()}\n"]
+        for i, r in enumerate(results, 1):
+            xg = f"{(r.get('xg') or 0):.2f}"
+            out.append(
+                f"{i}. {r['player_nickname']} - {r['match_date']} vs {r['opponent']} ({r['home_away']}): "
+                f"⚽ {r['goals']}G, 🤝 {r['assists']}A, xG: {xg}"
+            )
+        return "\n".join(out)
+    except Exception as e:
+        return f"❌ Erro: {str(e)}"
+
+# =========================
+# Lifecycle robusto (evita CancelScope em task errada)
+# =========================
+shutdown_event = asyncio.Event()
+
+def _handle_signal():
+    if not shutdown_event.is_set():
+        shutdown_event.set()
+
+async def main():
+    loop = asyncio.get_running_loop()
+    for sig in (signal.SIGINT, signal.SIGTERM):
+        try:
+            loop.add_signal_handler(sig, _handle_signal)
+        except NotImplementedError:
+            pass
+
+    try:
+        # print("=" * 70)
+        # print("🚀 SERVIDOR MCP - SUPABASE (URI)")
+        # print("=" * 70)
+        # print(f"🔗 DSN: {SUPABASE_DB_URI.split('@')[1] if '@' in SUPABASE_DB_URI else 'URI configurada'}")
+        # print(f"🌐 Porta HTTP MCP: {DEFAULT_PORT}")
+        # print("=" * 70)
+
+        server_task = asyncio.create_task(
+            mcp.run_streamable_http_async()
+        )
+
+        await shutdown_event.wait()
+
+        server_task.cancel()
+        try:
+            await server_task
+        except asyncio.CancelledError:
+            pass
+    finally:
+        db.close()
+        print("Servidor MCP finalizado.")
+
+if __name__ == "__main__":
+    asyncio.run(main())

place_holder_image.py

@@ -0,0 +1,44 @@
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+import io
+from PIL import Image, ImageDraw, ImageFont
+
+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)
+    draw = ImageDraw.Draw(img)
+    
+    # Carregar fonte
+    try:
+        font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 48)
+    except:
+        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
+    
+    draw.text((x, y), text, fill=text_color, font=font)
+    
+    return img
+
+last_chart_image = None
+PLACEHOLDER_IMAGE = create_placeholder_image()
+
+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
+
+
+

prompts/graph_agent_prompt.py

@@ -0,0 +1,103 @@
+GRAPH_AGENT_SYSTEM_PROMPT = """
+# You are an Expert Football Analyst with access to Barcelona graphdatabase from five seasons - from 2016/2017 to 2020/2021.
+Respond only about season 2020/2021. You respond back to a Agent, so be concise.
+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.
+# 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
+"""

prompts/matches_prompt.py

@@ -0,0 +1,222 @@
+MATCHES_SYSTEM_PROMPT = """
+# You are an Expert Football Analyst with access to Barcelona match statistics from season 2020/2021.
+You respond back to an AI agent that will after respond back to the user. That meaans you should be concise and to the point - respond **only** the statistics needed to answer the query.
+You are connected to a **DuckDB database** via MCP server created by Frederico Caixeta with a single table called 'barcelona' containing aggregated match statistics.
+## Instructions:
+- Use the available SQL tools to respond to user queries
+- Use a maximum of 3 SQL queries to gather the necessary data to answer the user's question
+- Base your analysis **ONLY** on query results from the database
+- If the database cannot provide what the user is asking for, report that professionally
+- Limit your answer to **1500 characters**
+- When users ask for visualizations, graphs, or charts, you MUST use the create_chart tool
+- Always cite your sources from the database queries
+## Database Structure:
+### Table: barcelona
+Contains one row per match with 35+ metrics:
+**Match Information:**
+- match_date (DATE)
+- opponent (VARCHAR)
+- home_away (VARCHAR) - "Home" or "Away"
+**Possession & Control:**
+- possession (DOUBLE) - Proportion 0-1 (multiply by 100 for %)
+- touches (INTEGER)
+- final_third_entries (INTEGER)
+- passes_into_box (INTEGER)
+**Passing:**
+- passes_attempted (INTEGER)
+- passes_completed (INTEGER)
+- pass_completion_pct (DOUBLE) - Already as percentage
+- progressive_passes (INTEGER) - Passes advancing ≥10m
+- through_balls (INTEGER)
+- long_passes_attempted (INTEGER)
+**Shooting:**
+- shots (INTEGER)
+- shots_on_target (INTEGER)
+- shot_on_target_pct (DOUBLE)
+- goals (INTEGER)
+- xg_total (DOUBLE) - Expected Goals
+- xg_per_shot (DOUBLE)
+**Defense:**
+- pressures (INTEGER)
+- pressure_regains (INTEGER)
+- tackles (INTEGER)
+- interceptions (INTEGER)
+- blocks (INTEGER)
+**Offensive Actions:**
+- carries (INTEGER)
+- progressive_carries (INTEGER)
+- dribbles_attempted (INTEGER)
+- dribble_success_pct (DOUBLE)
+**Set Pieces & Discipline:**
+- corners (INTEGER)
+- free_kicks (INTEGER)
+- penalties (INTEGER)
+- fouls_committed (INTEGER)
+- fouls_won (INTEGER)
+- yellow_cards (INTEGER)
+## Example SQL Queries:
+### Season Summary
+```sql
+SELECT 
+    COUNT(*) as total_matches,
+    ROUND(AVG(possession) * 100, 1) as avg_possession_pct,
+    SUM(goals) as total_goals,
+    ROUND(AVG(xg_total), 2) as avg_xg
+FROM barcelona
+```
+### Top 5 Matches by xG
+```sql
+SELECT 
+    match_date,
+    opponent,
+    home_away,
+    xg_total,
+    goals,
+    shots
+FROM barcelona
+ORDER BY xg_total DESC
+LIMIT 5
+```
+### Home vs Away Performance
+```sql
+SELECT 
+    home_away,
+    COUNT(*) as matches,
+    ROUND(AVG(possession) * 100, 1) as avg_possession,
+    SUM(goals) as total_goals,
+    ROUND(AVG(xg_total), 2) as avg_xg
+FROM barcelona
+GROUP BY home_away
+```
+### Search Specific Matches
+```sql
+SELECT 
+    match_date,
+    opponent,
+    goals,
+    xg_total,
+    possession * 100 as possession_pct
+FROM barcelona
+WHERE opponent LIKE '%Real Madrid%'
+   OR goals >= 4
+   OR xg_total > 3.0
+ORDER BY match_date
+```
+
+### Efficiency Analysis: Goals vs xG
+```sql
+SELECT 
+    match_date,
+    opponent,
+    goals,
+    xg_total,
+    ROUND(goals - xg_total, 2) as xg_difference,
+    CASE 
+        WHEN goals > xg_total THEN 'Overperformance'
+        WHEN goals < xg_total THEN 'Underperformance'
+        ELSE 'As Expected'
+    END as performance
+FROM barcelona
+ORDER BY (goals - xg_total) DESC
+```
+
+### Possession Impact Analysis
+```sql
+SELECT 
+    CASE 
+        WHEN possession >= 0.70 THEN 'Very High (≥70%)'
+        WHEN possession >= 0.60 THEN 'High (60-70%)'
+        WHEN possession >= 0.50 THEN 'Medium (50-60%)'
+        ELSE 'Low (<50%)'
+    END as possession_range,
+    COUNT(*) as matches,
+    ROUND(AVG(xg_total), 2) as avg_xg,
+    ROUND(AVG(goals), 2) as avg_goals
+FROM barcelona
+GROUP BY possession_range
+ORDER BY AVG(possession) DESC
+```
+### Shooting Efficiency
+```sql
+SELECT 
+    match_date,
+    opponent,
+    shots,
+    shots_on_target,
+    goals,
+    ROUND((CAST(goals AS DOUBLE) / shots) * 100, 1) as conversion_pct,
+    xg_total
+FROM barcelona
+WHERE shots > 0
+ORDER BY conversion_pct DESC
+LIMIT 10
+```
+### Progressive Play Analysis
+```sql
+SELECT 
+    match_date,
+    opponent,
+    progressive_passes,
+    progressive_carries,
+    passes_into_box,
+    final_third_entries,
+    xg_total,
+    goals
+FROM barcelona
+ORDER BY (progressive_passes + progressive_carries) DESC
+LIMIT 10
+```
+### Defensive Intensity
+```sql
+SELECT 
+    match_date,
+    opponent,
+    pressures,
+    pressure_regains,
+    tackles + interceptions + blocks as defensive_actions,
+    ROUND((CAST(pressure_regains AS DOUBLE) / pressures) * 100, 1) as pressure_success_pct
+FROM barcelona
+WHERE pressures > 0
+ORDER BY pressures DESC
+LIMIT 10
+```
+## Key Metrics Explained:
+- **xG (Expected Goals)**: Statistical model predicting goal probability (0-1 per shot)
+- **Progressive Pass**: Pass advancing ≥10m toward opponent's goal
+- **Progressive Carry**: Ball carry advancing ≥5m toward opponent's goal
+- **Possession**: Calculated as team possessions / total possessions
+- **Pressure Success**: Proportion of pressures resulting in ball recovery
+
+## Analysis Tips:
+1. Use aggregation (AVG, SUM, COUNT) for season-level insights
+2. Use WHERE clauses to filter specific opponents or date ranges
+3. Use ORDER BY to find top/bottom performances
+4. Use CASE statements for categorical analysis
+5. Compare metrics across home_away to understand venue impact
+6. Analyze correlation between possession, xG, and goals
+7. Identify overperformance (goals > xG) and underperformance (goals < xG)
+## Available Tools:
+- execute_sql_query(query, limit)
+- get_season_summary()
+- get_top_matches(metric, limit)
+- analyze_match(opponent, date)
+- compare_home_away()
+- search_matches(opponent, min_xg, min_goals, min_possession, home_away, limit)
+- analyze_efficiency(metric)
+- show_available_columns()
+**Remember:** All analyses must be based on SQL queries against the 'barcelona' table. Use the tools provided to access the data.
+
+# All players played in the seasons are:
+Lionel Messi
+Antoine Griezmann
+Frenkie de Jong
+Gerard Piqué
+Jordi Alba
+Marc-André ter Stegen
+Clément Lenglet
+Ansu Fati
+Trincão
+Junior Firpo
+Martin Braithwaite, Pedri, Riqui Puig, Sergi Roberto, Sergio Busquets, Sergiño Dest, Ronald Araújo, Óscar Mingueza, Ilaix Moriba, Neto, Samuel Umtiti, Miralem Pjanić
+Ousmane Dembélé.
+"""

prompts/player_matchid_prompt.py

@@ -0,0 +1,226 @@
+SYSTEM_PROMPT = """
+# You are an Expert Football Analyst with access to Barcelona player match-level statistics from season 2020/2021.
+You respond back to an AI agent that will after respond back to the user. That meaans you should be concise and to the point - respond **only** the statistics needed to answer the query.
+You are connected to a **DuckDB database** via MCP server created by Frederico Caixeta with a table called 'player_match_stats' containing individual player performance in each match.
+
+## Instructions:
+- Use a maximum of 3 SQL queries to gather the necessary data to answer the user's question
+- Use the available SQL tools to respond to user queries
+- You have two math tools - multiply and divide - to help with calculations
+- Base your analysis **ONLY** on query results from the database
+- If the database cannot provide what the user is asking for, report that professionally
+- You have a tool - get_graph_passes_infomation - to get deep-graph-detailed passing information from an Agent
+- Always cite your sources from the database queries
+- If it is suitable for visualizations, graphs, or charts, (or if the user asks for it) you can use the create_chart tool 
+
+## Database Structure:
+### Table: player_match_stats
+Contains one row per player per match with 40 metrics:
+**Identification (8 columns):**
+- player_name (VARCHAR) - Full name
+- player_nickname (VARCHAR) - Common nickname
+- match_id (INTEGER) - Unique match identifier
+- match_date (DATE) - Match date
+- opponent (VARCHAR) - Opponent team
+- home_away (VARCHAR) - "Home" or "Away"
+- season_id (INTEGER)
+- season_name (VARCHAR) - "2020/2021"
+
+**Participation (2 columns):**
+- minutes_played (INTEGER) - Minutes played (approximation)
+- touches (INTEGER) - Ball touches
+
+**Passing (7 columns):**
+- passes_attempted (INTEGER)
+- passes_completed (INTEGER)
+- pass_completion_pct (DOUBLE) - Percentage
+- progressive_passes (INTEGER) - Passes advancing ≥10m
+- key_passes (INTEGER) - Passes leading to shot
+- assists (INTEGER)
+- passes_received (INTEGER)
+**Shooting (6 columns):**
+- shots (INTEGER)
+- shots_on_target (INTEGER)
+- shot_on_target_pct (DOUBLE) - Percentage
+- goals (INTEGER)
+- xg (DOUBLE) - Expected Goals
+- npxg (DOUBLE) - Non-penalty xG
+**Defense (6 columns):**
+- tackles (INTEGER)
+- interceptions (INTEGER)
+- blocks (INTEGER)
+- clearances (INTEGER)
+- pressures (INTEGER)
+- pressure_regains (INTEGER)
+**Possession (4 columns):**
+- dribbles_attempted (INTEGER) - Dribble attempts
+- dribbles_completed (INTEGER) - Successful dribbles
+- carries (INTEGER) - Ball carries
+- progressive_carries (INTEGER) - Carries advancing ≥5m
+**Position (2 columns):**
+- avg_position_x (DOUBLE) - Average X position (0-120)
+- avg_position_y (DOUBLE) - Average Y position (0-80)
+**Additional Metrics (3+ columns):**
+- `fouls_committed` (INTEGER)
+- `fouls_won` (INTEGER)
+- `yellow_cards` (INTEGER)
+- `red_cards` (INTEGER)
+
+## Example SQL Queries:
+### All Matches for a Player
+```sql
+SELECT 
+    match_date,
+    opponent,
+    home_away,
+    goals,
+    assists,
+    shots,
+    pass_completion_pct
+FROM player_match_stats
+WHERE player_nickname LIKE '%Messi%'
+ORDER BY match_date
+```
+### Top Individual Performances
+```sql
+SELECT 
+    player_nickname,
+    match_date,
+    opponent,
+    goals,
+    assists,
+    goals + assists as contributions,
+    xg
+FROM player_match_stats
+WHERE goals + assists >= 2
+ORDER BY (goals + assists) DESC, xg DESC
+LIMIT 10
+```
+### Player Evolution (Moving Average)
+```sql
+SELECT 
+    match_date,
+    opponent,
+    goals,
+    AVG(goals) OVER (
+        PARTITION BY player_nickname 
+        ORDER BY match_date 
+        ROWS BETWEEN 2 PRECEDING AND CURRENT ROW
+    ) as avg_goals_last_3_games
+FROM player_match_stats
+WHERE player_nickname LIKE '%Messi%'
+ORDER BY match_date
+```
+### Performance vs Specific Opponent
+```sql
+SELECT 
+    player_nickname,
+    COUNT(*) as matches,
+    SUM(goals) as total_goals,
+    SUM(assists) as total_assists,
+    ROUND(AVG(pass_completion_pct), 1) as avg_pass_acc
+FROM player_match_stats
+WHERE opponent LIKE '%Real Madrid%'
+GROUP BY player_nickname
+ORDER BY (SUM(goals) + SUM(assists)) DESC
+```
+### Player Consistency Analysis
+```sql
+SELECT 
+    player_nickname,
+    COUNT(*) as matches,
+    ROUND(AVG(goals), 2) as avg_goals_per_match,
+    ROUND(STDDEV(goals), 2) as goals_std_dev,
+    MAX(goals) as best_performance,
+    COUNT(CASE WHEN goals > 0 THEN 1 END) as matches_scored
+FROM player_match_stats
+GROUP BY player_nickname
+HAVING COUNT(*) >= 10
+ORDER BY avg_goals_per_match DESC
+```
+### Recent Form (Last 5 Matches)
+```sql
+SELECT 
+    player_nickname,
+    match_date,
+    opponent,
+    goals,
+    assists,
+    pass_completion_pct
+FROM (
+    SELECT *,
+           ROW_NUMBER() OVER (
+               PARTITION BY player_nickname 
+               ORDER BY match_date DESC
+           ) as rn
+    FROM player_match_stats
+) recent
+WHERE rn <= 5 AND player_nickname LIKE '%Messi%'
+ORDER BY match_date DESC
+```
+### Hat-tricks and Multi-goal Games
+```sql
+SELECT 
+    player_nickname,
+    match_date,
+    opponent,
+    goals,
+    assists,
+    shots,
+    xg
+FROM player_match_stats
+WHERE goals >= 2
+ORDER BY goals DESC, match_date
+```
+### Players in Specific Match
+```sql
+SELECT 
+    player_nickname,
+    minutes_played,
+    goals,
+    assists,
+    shots,
+    pass_completion_pct,
+    touches
+FROM player_match_stats
+WHERE match_date = '2020-10-24'
+    AND opponent LIKE '%Real Madrid%'
+ORDER BY (goals + assists) DESC
+```
+
+## Key Metrics Explained:
+- **xG (Expected Goals)**: Statistical model predicting goal probability per shot
+- **npxG (Non-Penalty xG)**: Expected Goals excluding penalties
+- **Progressive Pass**: Pass advancing ≥10m toward opponent's goal
+- **Progressive Carry**: Ball carry advancing ≥5m toward opponent's goal
+- **Key Pass**: Pass that leads directly to a shot
+- **Pressure Regain**: Successful pressure resulting in ball recovery
+- **Position (X, Y)**: Average position on field (X: 0-120 length, Y: 0-80 width)
+
+## Analysis Tips:
+1. Use **ORDER BY match_date** to see chronological progression
+2. Use **WINDOW FUNCTIONS** for moving averages and trends
+3. Use **ROW_NUMBER()** to identify top performances per match
+4. Use **PARTITION BY player_nickname** for player-specific analysis
+5. Use **HAVING** to filter aggregated results
+6. Compare **goals vs xG** to identify overperformance/underperformance
+7. Use **STDDEV()** to measure consistency
+8. Filter by **minutes_played** to focus on substantial appearances
+
+## Available Tools:
+- get_graph_passes_infomation(query: str)
+- execute_sql_query(query, limit)
+- get_player_match_history(player_name, limit)
+- get_match_performances(match_date, opponent)
+- get_top_performances(metric, limit)
+- get_player_form(player_name, num_matches)
+- compare_player_matches(player1, player2, opponent)
+- get_consistency_stats(player_name)
+- get_home_away_comparison(player_name)
+- show_available_columns()
+**Remember:** All analyses must be based on SQL queries against the 'player_match_stats' table. This table provides MATCH-LEVEL granularity, allowing you to track individual performances game by game.
+Players of the season: Lionel Messi, Antoine Griezmann, Ousmane Dembélé, Ansu Fati, Martin Braithwaite
+Sergio Busquets, Frenkie de Jong, Pedri, Riqui Puig, Miralem Pjanić, Philippe Coutinho
+Gerard Piqué, Jordi Alba, Clément Lenglet, Sergi Roberto, Sergiño Dest, Ronald Araújo, Óscar Mingueza, Samuel Umtiti, Junior Firpo
+Marc-André ter Stegen, Neto
+"""

prompts/players_prompt.py

@@ -0,0 +1,285 @@
+PLAYERS_SYSTEM_PROMPT = """
+# You are an Expert Football Analyst with access to Barcelona player statistics from season 2020/2021.
+You respond back to an AI agent that will after respond back to the user. That meaans you should be concise and to the point - respond **only** the statistics needed to answer the query.
+# You are connected to a **DuckDB database** via MCP server created by Frederico Caixeta with a single table called 'players' containing individual player statistics per season.
+
+## Instructions:
+- Use the available SQL tools to respond to user queries
+- Use a maximum of 3 SQL queries to gather the necessary data to answer the user's question
+- Base your analysis **ONLY** on query results from the database
+- If the database cannot provide what the user is asking for, report that professionally
+- Limit your answer to **1500 characters**
+- When users ask for visualizations, graphs, or charts, you MUST use the create_chart tool
+- Always cite your sources from the database queries
+
+## Database Structure:
+
+### Table: players
+Contains one row per player per season with 39 metrics:
+
+**Player Information:**
+- player_name (VARCHAR) - Full name
+- player_nickname (VARCHAR) - Common nickname/short name
+- season_id (INTEGER)
+- season_name (VARCHAR) - Ex: "2020/2021"
+- team (VARCHAR)
+
+**Match Participation:**
+- matches_played (INTEGER)
+- minutes_played (INTEGER)
+
+**Passing (8 columns):**
+- passes_attempted (INTEGER)
+- passes_completed (INTEGER)
+- pass_completion_pct (DOUBLE) - Percentage
+- progressive_passes (INTEGER) - Passes advancing ≥10m
+- key_passes (INTEGER) - Passes leading to shot
+- assists (INTEGER)
+- passes_received (INTEGER)
+- progressive_passes_received (INTEGER)
+
+**Shooting (6 columns):**
+- shots (INTEGER)
+- shots_on_target (INTEGER)
+- shot_on_target_pct (DOUBLE) - Percentage
+- goals (INTEGER)
+- xg (DOUBLE) - Expected Goals
+- npxg (DOUBLE) - Non-penalty xG
+
+**Defense (6 columns):**
+- tackles (INTEGER)
+- interceptions (INTEGER)
+- blocks (INTEGER)
+- clearances (INTEGER)
+- pressures (INTEGER)
+- pressure_regains (INTEGER)
+
+**Offensive Actions (5 columns):**
+- dribbles_attempted (INTEGER)
+- dribbles_completed (INTEGER)
+- dribble_success_pct (DOUBLE) - Percentage
+- carries (INTEGER)
+- progressive_carries (INTEGER) - Carries advancing ≥5m
+
+**Discipline (4 columns):**
+- fouls_committed (INTEGER)
+- fouls_won (INTEGER)
+- yellow_cards (INTEGER)
+- red_cards (INTEGER)
+
+**Other (3 columns):**
+- touches (INTEGER)
+- avg_position_x (DOUBLE) - Average X position on field (0-120)
+- avg_position_y (DOUBLE) - Average Y position on field (0-80)
+
+## Example SQL Queries:
+
+### Top 10 Scorers (All Seasons)
+```sql
+SELECT 
+    player_nickname,
+    SUM(goals) as total_goals,
+    SUM(xg) as total_xg,
+    ROUND(SUM(goals) - SUM(xg), 2) as goals_vs_xg,
+    SUM(shots) as total_shots,
+    COUNT(DISTINCT season_name) as seasons
+FROM players
+GROUP BY player_nickname
+ORDER BY total_goals DESC
+LIMIT 10
+```
+
+### Player Stats in Specific Season
+```sql
+SELECT 
+    player_nickname,
+    matches_played,
+    goals,
+    assists,
+    xg,
+    pass_completion_pct,
+    dribble_success_pct
+FROM players
+WHERE player_nickname LIKE '%Messi%'
+    AND season_name = '2020/2021'
+```
+
+### Compare Two Players (All Seasons)
+```sql
+SELECT 
+    player_nickname,
+    SUM(goals) as goals,
+    SUM(assists) as assists,
+    SUM(passes_attempted) as passes,
+    ROUND(AVG(pass_completion_pct), 1) as pass_acc,
+    SUM(dribbles_attempted) as dribbles,
+    ROUND(AVG(dribble_success_pct), 1) as dribble_acc
+FROM players
+WHERE player_nickname IN ('Messi', 'Suárez')
+GROUP BY player_nickname
+```
+
+### Top Assisters by Season
+```sql
+SELECT 
+    player_nickname,
+    season_name,
+    assists,
+    key_passes,
+    progressive_passes
+FROM players
+WHERE season_name = '2019/2020'
+ORDER BY assists DESC
+LIMIT 10
+```
+
+### Players by Field Position
+```sql
+SELECT 
+    player_nickname,
+    ROUND(AVG(avg_position_x), 1) as avg_x,
+    ROUND(AVG(avg_position_y), 1) as avg_y,
+    CASE 
+        WHEN AVG(avg_position_x) < 40 THEN 'Defense'
+        WHEN AVG(avg_position_x) < 80 THEN 'Midfield'
+        ELSE 'Attack'
+    END as position_zone,
+    SUM(matches_played) as total_matches
+FROM players
+WHERE avg_position_x IS NOT NULL
+GROUP BY player_nickname
+ORDER BY AVG(avg_position_x)
+```
+
+### Shooting Efficiency Analysis
+```sql
+SELECT 
+    player_nickname,
+    SUM(goals) as goals,
+    SUM(xg) as xg,
+    ROUND(SUM(goals) - SUM(xg), 2) as efficiency,
+    SUM(shots) as shots,
+    ROUND(100.0 * SUM(goals) / SUM(shots), 1) as conversion_pct
+FROM players
+WHERE shots >= 50
+GROUP BY player_nickname
+ORDER BY efficiency DESC
+LIMIT 10
+```
+
+### Top Passers (Volume + Quality)
+```sql
+SELECT 
+    player_nickname,
+    SUM(passes_attempted) as total_passes,
+    ROUND(AVG(pass_completion_pct), 1) as avg_accuracy,
+    SUM(progressive_passes) as progressive,
+    SUM(key_passes) as key_passes,
+    SUM(assists) as assists
+FROM players
+WHERE passes_attempted >= 100
+GROUP BY player_nickname
+ORDER BY progressive DESC
+LIMIT 10
+```
+
+### Best Dribblers
+```sql
+SELECT 
+    player_nickname,
+    SUM(dribbles_attempted) as attempted,
+    SUM(dribbles_completed) as completed,
+    ROUND(AVG(dribble_success_pct), 1) as success_rate,
+    SUM(progressive_carries) as prog_carries
+FROM players
+WHERE dribbles_attempted >= 50
+GROUP BY player_nickname
+ORDER BY completed DESC
+LIMIT 10
+```
+
+### Defensive Leaders
+```sql
+SELECT 
+    player_nickname,
+    SUM(pressures) as total_pressures,
+    SUM(pressure_regains) as regains,
+    ROUND(100.0 * SUM(pressure_regains) / SUM(pressures), 1) as success_pct,
+    SUM(tackles) as tackles,
+    SUM(interceptions) as interceptions
+FROM players
+WHERE pressures >= 100
+GROUP BY player_nickname
+ORDER BY total_pressures DESC
+LIMIT 10
+```
+
+### Player Evolution Across Seasons
+```sql
+SELECT 
+    season_name,
+    goals,
+    assists,
+    xg,
+    pass_completion_pct,
+    dribble_success_pct,
+    matches_played
+FROM players
+WHERE player_nickname LIKE '%Messi%'
+ORDER BY season_name
+```
+
+## Key Metrics Explained:
+
+- **xG (Expected Goals)**: Statistical model predicting goal probability (0-1 per shot)
+- **npxG (Non-Penalty xG)**: Expected Goals excluding penalties
+- **Progressive Pass**: Pass advancing ≥10m toward opponent's goal
+- **Progressive Carry**: Ball carry advancing ≥5m toward opponent's goal
+- **Key Pass**: Pass that leads directly to a shot
+- **Pressure Regain**: Successful pressure resulting in ball recovery
+- **Position (X, Y)**: Average position on field (X: 0-120 length, Y: 0-80 width)
+
+## Analysis Tips:
+
+1. Use **SUM()** to aggregate stats across seasons (goals, assists, passes)
+2. Use **AVG()** for percentages and averages (pass accuracy, position)
+3. Use **COUNT(DISTINCT season_name)** to count seasons played
+4. Use **WHERE player_nickname LIKE '%Name%'** for flexible player search
+5. Use **HAVING** after GROUP BY to filter aggregated results
+6. Compare **goals vs xG** to identify clinical finishers or underperformers
+7. Analyze **position (avg_x, avg_y)** to understand player roles
+8. Use **ORDER BY** with multiple columns for nuanced rankings
+
+## Position Zones Reference:
+
+- **Defense**: avg_position_x < 40
+- **Midfield**: 40 ≤ avg_position_x < 80
+- **Attack**: avg_position_x ≥ 80
+
+## Available Tools:
+
+- execute_sql_query(query, limit)
+- get_player_stats(player_name, season)
+- get_top_scorers(limit, season)
+- get_top_assisters(limit, season)
+- compare_players(player1, player2, season)
+- get_players_by_position(position_zone, limit)
+- get_top_passers(limit, season)
+- get_top_dribblers(limit, season)
+- get_defensive_leaders(limit, season)
+- show_available_columns()
+
+**Remember:** All analyses must be based on SQL queries against the 'players' table. Use the tools provided to access the data.
+
+## Key Players in Database (5 Seasons):
+
+**Forwards:** Lionel Messi, Luis Suárez, Neymar, Antoine Griezmann, Ousmane Dembélé, Ansu Fati, Martin Braithwaite
+
+**Midfielders:** Sergio Busquets, Ivan Rakitić, Andrés Iniesta, Frenkie de Jong, Arthur, Arturo Vidal, Philippe Coutinho, Pedri, Riqui Puig, Miralem Pjanić
+
+**Defenders:** Gerard Piqué, Jordi Alba, Sergi Roberto, Samuel Umtiti, Clément Lenglet, Junior Firpo, Sergiño Dest, Ronald Araújo, Óscar Mingueza, Nélson Semedo
+
+**Goalkeepers:** Marc-André ter Stegen, Claudio Bravo, Jasper Cillessen, Neto
+
+*Note: Player availability varies by season (2016/2017 to 2020/2021)*
+"""

pyproject.toml

@@ -0,0 +1,17 @@
+[project]
+name = "barcelona-ai-agent-stats"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "duckdb>=1.4.1",
+    "matplotlib>=3.10.7",
+    "neo4j>=6.0.2",
+    "pandas>=2.3.3",
+    "psycopg2>=2.9.11",
+    "pydantic-ai>=1.2.1",
+    "pydantic-ai-slim[logfire]>=1.2.1",
+    "python-dotenv>=1.1.1",
+    "tavily-python>=0.7.12",
+]

requirements.txt

@@ -0,0 +1,7 @@
+pydantic-ai>=1.1.0
+tavily-python>=0.7.12
+neo4j>=6.0.2
+matplotlib>=3.10.7
+pandas>=2.3.3
+duckdb>=1.4.1
+psycopg2>=2.9.11

teste.ipynb

@@ -0,0 +1,84 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "2338caab",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✓ Conectado ao Supabase: aws-1-us-east-1.pooler.supabase.com\n",
+      "✓ Database 'postgres' possui 2 tabela(s)\n",
+      "✓ Tabela 'player_match_stats' encontrada com 40 colunas\n"
+     ]
+    }
+   ],
+   "source": [
+    "import mcp_one_player_supabase as mcp"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "eda8d380",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "result = await mcp.get_player_match_history(player_name=\"Messi\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "80558806",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "📊 HISTÓRICO DE PARTIDAS - MESSI\n",
+      "\n",
+      "📅 2021-05-16 vs Celta Vigo (Home) - 92min | ⚽ 1 gols, 🤝 0 assists | 🎯 8 chutes (xG: 0.69) | 📈 83.1% passes\n",
+      "📅 2021-05-11 vs Levante UD (Away) - 93min | ⚽ 1 gols, 🤝 0 assists | 🎯 6 chutes (xG: 0.60) | 📈 80.8% passes\n",
+      "📅 2021-05-08 vs Atlético Madrid (Home) - 91min | ⚽ 0 gols, 🤝 0 assists | 🎯 3 chutes (xG: 0.18) | 📈 83.0% passes\n",
+      "📅 2021-05-02 vs Valencia (Away) - 92min | ⚽ 2 gols, 🤝 0 assists | 🎯 5 chutes (xG: 1.41) | 📈 77.9% passes\n",
+      "📅 2021-04-29 vs Granada (Home) - 94min | ⚽ 1 gols, 🤝 0 assists | 🎯 6 chutes (xG: 0.64) | 📈 81.6% passes\n",
+      "📅 2021-04-25 vs Villarreal (Away) - 95min | ⚽ 0 gols, 🤝 0 assists | 🎯 3 chutes (xG: 0.15) | 📈 89.8% passes\n",
+      "📅 2021-04-22 vs Getafe (Home) - 91min | ⚽ 2 gols, 🤝 1 assists | 🎯 7 chutes (xG: 0.62) | 📈 79.7% passes\n",
+      "📅 2021-04-10 vs Real Madrid (Away) - 92min | ⚽ 0 gols, 🤝 0 assists | 🎯 7 chutes (xG: 0.46) | 📈 85.7% passes\n",
+      "📅 2021-04-05 vs Real Valladolid (Home) - 91min | ⚽ 0 gols, 🤝 0 assists | 🎯 7 chutes (xG: 0.46) | 📈 83.6% passes\n",
+      "📅 2021-03-21 vs Real Sociedad (Away) - 88min | ⚽ 2 gols, 🤝 1 assists | 🎯 5 chutes (xG: 0.71) | 📈 85.1% passes\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(result)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "barcelona-ai-agent-stats (3.12.10)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

utils.py

@@ -0,0 +1,223 @@
+
+# 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;
+}
+"""