Prueba en HF

README.md

@@ -1,16 +1,72 @@
----
-title: MCP Crypto
-emoji: 💻
-colorFrom: gray
-colorTo: indigo
-sdk: gradio
-sdk_version: 5.32.1
-app_file: app.py
-pinned: false
-license: apache-2.0
-short_description: Agents-MCP-Hackathon
-tags:
-  - mcp-server-track
+# Financial Analyst con Claude (Anthropic) y MCP
+
+Una aplicación de análisis financiero que utiliza servidores MCP para análisis de acciones y generación de reportes, con interfaz web Gradio y modelo Claude (Anthropic).
+
+## Casos de uso
+
+- Obtener precios de acciones en tiempo real, datos históricos y recomendaciones de analistas
+- Generar reportes financieros breves y profesionales
+- Guardar reportes en archivos
+
+## Arquitectura
+
+```
+├── mcp_servers/
+│   ├── stdio_yfinance_server.py         # Datos de Yahoo Finance (precios, históricos)
+│   ├── stdio_report_gen_server.py       # Generación de reportes con Claude (Anthropic)
+│   └── stdio_save_report_server.py      # Guardado de reportes
+├── app.py                              # Interfaz Gradio (Hugging Face compatible)
+├── requirements.txt                    # Dependencias
+```
+
+### Aplicación principal
+- **app.py**: Interfaz Gradio que se comunica con los MCP servers por stdio. Permite ingresar información financiera y obtener un reporte generado por Claude.
+
+### MCP Servers
+- **stdio_yfinance_server.py**: Obtiene datos de Yahoo Finance (precios, históricos, recomendaciones)
+- **stdio_report_gen_server.py**: Genera reportes usando Claude (Anthropic)
+- **stdio_save_report_server.py**: Guarda reportes en archivos locales
+
+## Instalación
+
+```bash
+pip install -r requirements.txt
+```
+
+## Configuración de entorno
+
+Debes tener una API Key de Anthropic:
+
+```bash
+set ANTHROPIC_API_KEY="tu_api_key_de_anthropic"
+```
+
+(En Linux/Mac usa `export` en vez de `set`)
+
+## Uso
+
+1. Ejecuta la aplicación:
+   ```bash
+   python app.py
+   ```
+2. Se abrirá una interfaz web Gradio donde puedes ingresar información financiera y obtener el reporte generado.
+
+## Integración MCP
+
+La aplicación utiliza los MCP servers ubicados en `mcp_servers/` para cada función:
+- **Análisis de datos financieros:** `stdio_yfinance_server.py`
+- **Generación de reportes:** `stdio_report_gen_server.py` (usa Claude)
+- **Guardado de reportes:** `stdio_save_report_server.py`
+
+Puedes lanzar cada servidor MCP individualmente si lo deseas:
+```bash
+python mcp_servers/stdio_yfinance_server.py
+python mcp_servers/stdio_report_gen_server.py
+python mcp_servers/stdio_save_report_server.py
+```
+
+La interfaz Gradio (`app.py`) se comunica con el servidor de generación de reportes por stdio. Puedes adaptar la integración para usar los otros MCP servers según tus necesidades.
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+**Desarrollado para Hugging Face Spaces y entornos compatibles.**

app.py

@@ -1,34 +1,89 @@
+import os
 import gradio as gr
-from textblob import TextBlob
-
-def sentiment_analysis(text: str) -> dict:
-    """
-    Analyze the sentiment of the given text.
-
-    Args:
-        text (str): The text to analyze
-
-    Returns:
-        dict: A dictionary containing polarity, subjectivity, and assessment
-    """
-    blob = TextBlob(text)
-    sentiment = blob.sentiment
-    
-    return {
-        "polarity": round(sentiment.polarity, 2),  # -1 (negative) to 1 (positive)
-        "subjectivity": round(sentiment.subjectivity, 2),  # 0 (objective) to 1 (subjective)
-        "assessment": "positive" if sentiment.polarity > 0 else "negative" if sentiment.polarity < 0 else "neutral"
+import subprocess
+import sys
+import json
+import threading
+import time
+
+# Ruta al server MCP
+SERVER_PATH = os.path.abspath(os.path.join("mcp_servers", "stdio_report_gen_server.py"))
+
+# Mantener el proceso del servidor MCP abierto durante toda la sesión
+def start_mcp_server():
+    proc = subprocess.Popen(
+        [sys.executable, SERVER_PATH],
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        bufsize=1
+    )
+    print(f"[DEBUG] MCP STDIN: {proc.stdin}, STDOUT: {proc.stdout}, STDERR: {proc.stderr}")
+    return proc
+
+mcp_proc = start_mcp_server()
+lock = threading.Lock()  # Para evitar condiciones de carrera en stdio
+
+# Lee stderr de MCP en un hilo y guarda los logs
+stderr_logs = []
+def read_stderr(proc):
+    while True:
+        line = proc.stderr.readline()
+        if not line:
+            break
+        stderr_logs.append(line)
+        print("[MCP STDERR]", line.strip())
+
+stderr_thread = threading.Thread(target=read_stderr, args=(mcp_proc,), daemon=True)
+stderr_thread.start()
+
+# Comunicación usando JSON-RPC mínimo con timeout y logs
+
+def call_mcp_server(prompt):
+    request = {
+        "jsonrpc": "2.0",
+        "id": 1,
+        "method": "get_current_stock_price",  # Cambiado para probar el método
+        "params": [prompt]
     }
+    try:
+        with lock:
+            print(f"[APP] Enviando petición al MCP: {json.dumps(request)}")
+            mcp_proc.stdin.write(json.dumps(request) + "\n")
+            mcp_proc.stdin.flush()
+            # Esperar respuesta con timeout
+            start_time = time.time()
+            response_line = ''
+            while True:
+                if mcp_proc.stdout.closed:
+                    return "El servidor MCP se cerró inesperadamente."
+                if mcp_proc.stdout.readable():
+                    response_line = mcp_proc.stdout.readline()
+                    print(f"[APP] Recibido de MCP: {response_line}")
+                    if response_line.strip():
+                        break
+                if time.time() - start_time > 30:
+                    return f"Timeout esperando respuesta del servidor MCP. Logs recientes: {''.join(stderr_logs[-10:])}"
+                time.sleep(0.1)
+        if not response_line:
+            return "No se recibió respuesta del servidor MCP."
+        response = json.loads(response_line)
+        if "result" in response:
+            return response["result"]
+        elif "error" in response:
+            return f"Error del servidor MCP: {response['error']}\nLogs recientes: {''.join(stderr_logs[-10:])}"
+        else:
+            return f"Respuesta inesperada del servidor MCP. Logs recientes: {''.join(stderr_logs[-10:])}"
+    except Exception as e:
+        return f"Error comunicando con el servidor MCP: {str(e)}\nLogs recientes: {''.join(stderr_logs[-10:])}"
 
-# Create the Gradio interface
-demo = gr.Interface(
-    fn=sentiment_analysis,
-    inputs=gr.Textbox(placeholder="Enter text to analyze..."),
-    outputs=gr.JSON(),
-    title="Text Sentiment Analysis",
-    description="Analyze the sentiment of text using TextBlob"
-)
+with gr.Blocks() as demo:
+    gr.Markdown("# Generador de Reportes Financieros (Claude + MCP)")
+    prompt = gr.Textbox(label="Información financiera de la empresa")
+    output = gr.Textbox(label="Reporte generado")
+    btn = gr.Button("Generar reporte")
+    btn.click(fn=call_mcp_server, inputs=prompt, outputs=output)
 
-# Launch the interface and MCP server
 if __name__ == "__main__":
-    demo.launch(mcp_server=True)
+    demo.launch()

mcp_servers/stdio_report_gen_server.py

@@ -0,0 +1,33 @@
+from mcp.server.fastmcp import FastMCP
+import logging
+import os
+from typing import List
+import anthropic  
+import sys
+import asyncio
+
+# Configure logging to only show errors
+logging.basicConfig(level=logging.ERROR)
+
+# Initialize FastMCP server for report generation
+mcp = FastMCP("test_server")
+
+print("[MCP] Servidor de generación de reportes iniciado y esperando peticiones...", file=sys.stderr)
+
+# Initialize Anthropic client for report content generation
+client = anthropic.Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))  # Usa variable de entorno
+
+# System prompt to guide the LLM in generating financial reports
+system_prompt = "You are a professional financial analyst. Generate a very short report based on following information regarding different companies."
+
+@mcp.tool()
+def get_current_stock_price(symbol: str) -> str:
+    print(f"[MCP] Petición recibida: {symbol}", file=sys.stderr)
+    return f"Echo: {symbol}"
+
+def run_report_server():
+    """Start the report generation MCP server using stdio transport"""
+    mcp.run(transport="stdio")
+
+if __name__ == "__main__":
+    run_report_server()

mcp_servers/stdio_save_report_server.py

@@ -0,0 +1,29 @@
+from mcp.server.fastmcp import FastMCP
+import logging
+
+# Configure logging to only show errors
+logging.basicConfig(level=logging.ERROR)
+
+# Initialize FastMCP server for saving reports
+mcp = FastMCP("save-report")
+
+@mcp.tool()
+async def save_report(report: str, file_name: str="report.md") -> None:
+    """
+    Save the generated financial report to a file
+    
+    Args:
+        report (str): The report content to be saved
+        file_name (str): The filename to save the report to. Defaults to "report.md"
+    """
+    # Append the report content to the specified file
+    with open(file_name, "a") as file:
+        file.write(report + "\n")
+    print("Report saved successfully!")
+
+def run_save_report_server():
+    """Start the report saving MCP server using stdio transport"""
+    mcp.run(transport="stdio")
+
+if __name__ == "__main__":
+    run_save_report_server()

mcp_servers/stdio_yfinance_server.py

@@ -0,0 +1,76 @@
+from mcp.server.fastmcp import FastMCP
+import logging
+import yfinance as yf
+import json
+
+# Configure logging to only show errors
+logging.basicConfig(level=logging.ERROR)
+
+# Initialize FastMCP server for Yahoo Finance integration
+mcp = FastMCP("yfinance")
+
+# Tools are adapted from https://github.com/agno-agi/agno/blob/main/libs/agno/agno/tools/yfinance.py
+@mcp.tool()
+async def get_current_stock_price(symbol: str) -> str:
+    """
+    Use this function to get the current stock price for a given symbol.
+
+    Args:
+        symbol (str): The stock symbol.
+
+    Returns:
+        str: The current stock price or error message.
+    """
+    try:
+        stock = yf.Ticker(symbol)
+        current_price = stock.info.get("regularMarketPrice", stock.info.get("currentPrice"))
+        return f"{current_price:.4f}" if current_price else f"Could not fetch current price for {symbol}"
+    except Exception as e:
+        return f"Error fetching current price for {symbol}: {e}"
+
+@mcp.tool()
+async def get_historical_stock_prices(symbol: str, period: str = "1mo", interval: str = "1d") -> str:
+    """
+    Use this function to get the historical stock price for a given symbol.
+
+    Args:
+        symbol (str): The stock symbol.
+        period (str): The period for which to retrieve historical prices. Defaults to "1mo".
+                      Valid periods: 1d,5d,1mo,3mo,6mo,1y,2y,5y,10y,ytd,max
+        interval (str): The interval between data points. Defaults to "1d".
+                        Valid intervals: 1d,5d,1wk,1mo,3mo
+
+    Returns:
+        str: The historical stock price or error message.
+    """
+    try:
+        stock = yf.Ticker(symbol)
+        historical_price = stock.history(period=period, interval=interval)
+        return historical_price.to_json(orient="index")
+    except Exception as e:
+        return f"Error fetching historical prices for {symbol}: {e}"
+
+@mcp.tool()
+async def get_analyst_recommendations(symbol: str) -> str:
+    """
+    Use this function to get analyst recommendations for a given stock symbol.
+
+    Args:
+        symbol (str): The stock symbol.
+
+    Returns:
+        str: JSON containing analyst recommendations or error message.
+    """
+    try:
+        stock = yf.Ticker(symbol)
+        recommendations = stock.recommendations
+        return recommendations.to_json(orient="index")
+    except Exception as e:
+        return f"Error fetching analyst recommendations for {symbol}: {e}"
+
+def run_yfinance_server():
+    """Start the Yahoo Finance MCP server using stdio transport"""
+    mcp.run(transport="stdio")
+
+if __name__ == "__main__":
+    run_yfinance_server()

requirements.txt

@@ -1,2 +1,4 @@
-"gradio[mcp]"
-textblob
+gradio
+anthropic
+mcp
+yfinance