toollls

app.py

@@ -10,8 +10,8 @@ USER_ID = str(uuid.uuid4())
 # 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_one_player_supabase.py"])     
+# time.sleep(3)
 # subprocess.Popen(["python", "mcp_graph_server.py"])   
 # time.sleep(3)
 

main_agent.py

@@ -1,341 +1,209 @@
 import asyncio
+import os
+from typing import List, Dict, Any, Optional
+from pathlib import Path
+from functools import partial
+from dotenv import load_dotenv
+from psycopg2 import pool
+from psycopg2.extras import RealDictCursor
+load_dotenv()
+
 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
+from pydantic import BaseModel
 
-# import logfire
-# logfire.configure()  
-# logfire.instrument_pydantic_ai() 
-
-
-#PROMPTS
+# 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
+GRAPH_AGENT_SYSTEM_PROMPT = graph_agent_prompt.GRAPH_AGENT_SYSTEM_PROMPT  # Ajustado
 
 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
+SUPABASE_DB_URI = os.getenv("SUPABASE_DB_URI")
+
+# ========================= SupabaseConnection (migrada do MCP) =========================
+class SupabaseConnection:
+    def __init__(self, dsn: str):
+        self.pool = pool.ThreadedConnectionPool(minconn=1, maxconn=10, dsn=dsn)
+        print("✓ Pool Supabase criado")
+        # Teste conexão
+        conn = self.pool.getconn()
+        try:
+            with conn.cursor() as cur:
+                cur.execute("SELECT 1")
+        finally:
+            self.pool.putconn(conn)
+
+    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 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)
+
+# ========================= Agents (sem MCP) =========================
 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)
-)
+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)
-)
+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,
+one_player_agent = Agent(
+    model=groq_model,
+    system_prompt=PLAYER_MATCHID_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
+# ========================= TOOLS DIRETAS no one_player_agent =========================
+@one_player_agent.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 "❌ Apenas SELECT permitidas."
     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)}"
+        if 'LIMIT' not in query_upper:
+            query += f" LIMIT {limit}"
+        results = await db.execute_query_async(query)
+        if not results:
+            return "✓ Query OK, sem resultados."
+        lines = [f"📊 {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... +{len(results)-10}")
+        return "\n".join(lines)
+    except Exception as e:
+        return f"❌ Erro: {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:
+@one_player_agent.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
     """
-    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
+    try:
+        results = await db.execute_query_async(query, (f'%{player_name}%', limit))
+        if not results: return f"❌ Nenhum dado para '{player_name}'"
+        out = [f"📊 HISTÓRICO - {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']}) - {r['minutes_played']}min | ⚽{r['goals']}G 🤝{r['assists']}A | 🎯{r['shots']} (xG:{xg}) | 📈{pcp}%")
+        return "\n".join(out)
+    except Exception as e:
+        return f"❌ Erro: {str(e)}"
+
+@one_player_agent.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
     """
-    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** 📊"
-        
+        results = await db.execute_query_async(query, tuple(params))
+        if not results: return "❌ Partida não encontrada"
+        info = f"{match_date or ''} vs {opponent or ''}".strip()
+        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): ⚽{r['goals']}G + 🤝{r['assists']}A = {r['contributions']} | 🎯{r['shots']} (xG:{xg}) | 📈{pcp}% | 👟{touches}")
+        return "\n".join(out)
     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)
-#     """
+        return f"❌ Erro: {str(e)}"
+
+@one_player_agent.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étricas: {', '.join(valid)}"
+    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 "❌ Sem dados"
+        out = [f"🏆 TOP {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']}): ⚽{r['goals']}G 🤝{r['assists']}A xG:{xg}")
+        return "\n".join(out)
+    except Exception as e:
+        return f"❌ Erro: {str(e)}"
 
-#     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)
+# Manter create_chart (já era tool local)
+last_chart_image = None
+# ... (código do create_chart igual, global last_chart_image)
 
+# Funções de response (já sem MCP)
 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
-       
+    return res.output
+
 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
-        
+                if isinstance(node, End) and agent_run.result:
+                    return str(agent_run.result.output)
     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)
+        return f"Erro: {str(e)}"
+    return "Nenhuma resposta."
 
+# Cleanup global
+async def shutdown():
+    db.close()
 
 if __name__ == "__main__":
-    asyncio.run(test_safe())
+    asyncio.run(one_player_agent.run("Teste: top performances goals limit 5"))