"""uniprot_mcp_server.py — Exponer la API REST de UniProt como herramienta MCP.

Un servidor MCP puede exponer varias herramientas. Aquí hay 3:
- search_protein: Búsqueda de proteínas mediante consulta de texto
- get_protein_details: Detalles de información por accession
- get_sequence: obtener secuencia FASTA por accession
"""
import asyncio
import json
from typing import Any

import requests
from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp.types import Tool, TextContent


UNIPROT_BASE = "https://rest.uniprot.org"
server = Server("uniprot-mcp")


@server.list_tools()
async def list_tools() -> list[Tool]:
    return [
        Tool(
            name="search_protein",
            description="Buscar proteínas en UniProt mediante consulta de texto. Devuelve los K primeros resultados.",
            inputSchema={
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "Término de búsqueda (por ejemplo, 'p53 human')"},
                    "limit": {"type": "integer", "default": 10},
                },
                "required": ["query"],
            },
        ),
        Tool(
            name="get_protein_details",
            description="Obtener información detallada de la proteína por accession de UniProt.",
            inputSchema={
                "type": "object",
                "properties": {"accession": {"type": "string"}},
                "required": ["accession"],
            },
        ),
        Tool(
            name="get_sequence",
            description="Devuelve la secuencia FASTA del accession de UniProt.",
            inputSchema={
                "type": "object",
                "properties": {"accession": {"type": "string"}},
                "required": ["accession"],
            },
        ),
    ]


@server.call_tool()
async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
    """Despacho por nombre de herramienta. En producción, se recomienda separar cada función."""
    try:
        if name == "search_protein":
            result = _search_protein(arguments["query"], arguments.get("limit", 10))
        elif name == "get_protein_details":
            result = _get_details(arguments["accession"])
        elif name == "get_sequence":
            result = _get_sequence(arguments["accession"])
        else:
            raise ValueError(f"Unknown tool: {name}")
        return [TextContent(type="text", text=json.dumps(result, ensure_ascii=False, indent=2))]
    except requests.RequestException as e:
        return [TextContent(type="text", text=json.dumps({"error": f"Error en la API de UniProt: {e}"}))]
    except Exception as e:
        return [TextContent(type="text", text=json.dumps({"error": str(e)}))]


def _search_protein(query: str, limit: int) -> dict:
    resp = requests.get(
        f"{UNIPROT_BASE}/uniprotkb/search",
        params={
            "query": query,
            "format": "json",
            "size": limit,
            "fields": "accession,id,protein_name,organism_name,length",
        },
        timeout=30,
    )
    resp.raise_for_status()
    results = resp.json().get("results", [])
    return {"count": len(results), "results": results}


def _get_details(accession: str) -> dict:
    resp = requests.get(
        f"{UNIPROT_BASE}/uniprotkb/{accession}.json",
        timeout=30,
    )
    resp.raise_for_status()
    data = resp.json()
    return {
        "accession": data.get("primaryAccession"),
        "protein_name": data.get("proteinDescription", {}),
        "organism": data.get("organism", {}),
        "length": data.get("sequence", {}).get("length"),
        "function": [
            c["texts"][0]["value"]
            for c in data.get("comments", [])
            if c.get("commentType") == "FUNCTION"
        ],
    }


def _get_sequence(accession: str) -> dict:
    resp = requests.get(f"{UNIPROT_BASE}/uniprotkb/{accession}.fasta", timeout=30)
    resp.raise_for_status()
    lines = resp.text.strip().split("\n")
    return {
        "accession": accession,
        "header": lines[0],
        "sequence": "".join(lines[1:]),
    }


async def main():
    async with stdio_server() as (read_stream, write_stream):
        await server.run(read_stream, write_stream, server.create_initialization_options())


if __name__ == "__main__":
    asyncio.run(main())

"""pubmed_mcp_server.py — PubMed E-utilities MCP tool."""
import asyncio
import json
from xml.etree import ElementTree as ET

import requests
from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp.types import Tool, TextContent


EUTILS_BASE = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils"
server = Server("pubmed-mcp")


@server.list_tools()
async def list_tools() -> list[Tool]:
    return [
        Tool(
            name="search_pubmed",
            description="Obtener lista de artículos (PMID) de PubMed mediante término de búsqueda.",
            inputSchema={
                "type": "object",
                "properties": {
                    "query": {"type": "string"},
                    "max_results": {"type": "integer", "default": 20},
                    "date_range_years": {"type": "integer", "default": 5},
                },
                "required": ["query"],
            },
        ),
        Tool(
            name="fetch_abstracts",
            description="Obtener información detallada de resúmenes, autores y revistas a partir de una lista de PMIDs.",
            inputSchema={
                "type": "object",
                "properties": {
                    "pmids": {"type": "array", "items": {"type": "string"}},
                },
                "required": ["pmids"],
            },
        ),
    ]


@server.call_tool()
async def call_tool(name: str, arguments: dict) -> list[TextContent]:
    try:
        if name == "search_pubmed":
            result = _search(arguments["query"], arguments.get("max_results", 20), arguments.get("date_range_years", 5))
        elif name == "fetch_abstracts":
            result = _fetch(arguments["pmids"])
        else:
            raise ValueError(f"Unknown tool: {name}")
        return [TextContent(type="text", text=json.dumps(result, ensure_ascii=False, indent=2))]
    except Exception as e:
        return [TextContent(type="text", text=json.dumps({"error": str(e)}))]


def _search(query: str, max_results: int, date_range_years: int) -> dict:
    esearch = requests.get(
        f"{EUTILS_BASE}/esearch.fcgi",
        params={
            "db": "pubmed",
            "term": query,
            "retmax": max_results,
            "reldate": date_range_years * 365,
            "datetype": "pdat",
            "retmode": "json",
        },
        timeout=30,
    )
    esearch.raise_for_status()
    pmids = esearch.json().get("esearchresult", {}).get("idlist", [])
    return {"query": query, "count": len(pmids), "pmids": pmids}


def _fetch(pmids: list[str]) -> list[dict]:
    if not pmids:
        return []
    efetch = requests.get(
        f"{EUTILS_BASE}/efetch.fcgi",
        params={"db": "pubmed", "id": ",".join(pmids), "rettype": "abstract", "retmode": "xml"},
        timeout=60,
    )
    efetch.raise_for_status()
    root = ET.fromstring(efetch.content)
    articles = []
    for art in root.findall(".//PubmedArticle"):
        pmid = art.findtext(".//PMID")
        title = art.findtext(".//ArticleTitle") or ""
        abstract = " ".join(t.text or "" for t in art.findall(".//AbstractText"))
        authors = [
            f"{a.findtext('LastName') or ''} {a.findtext('Initials') or ''}".strip()
            for a in art.findall(".//Author")
        ]
        journal = art.findtext(".//Journal/Title") or ""
        year = art.findtext(".//PubDate/Year") or ""
        articles.append({
            "pmid": pmid,
            "title": title,
            "abstract": abstract,
            "authors": authors[:10],
            "journal": journal,
            "year": year,
        })
    return articles


async def main():
    async with stdio_server() as (read_stream, write_stream):
        await server.run(read_stream, write_stream, server.create_initialization_options())


if __name__ == "__main__":
    asyncio.run(main())

"""blast_mcp_server.py — NCBI BLAST QBlast (versión resumida, solo lógica esencial)."""
import time
import re
import requests

BLAST_URL = "https://blast.ncbi.nlm.nih.gov/Blast.cgi"


def submit_blast(sequence: str, program: str = "blastp", database: str = "nr") -> str:
    """Devuelve el RID de QBlast. Requiere polling posterior."""
    resp = requests.post(BLAST_URL, data={
        "CMD": "Put",
        "PROGRAM": program,
        "DATABASE": database,
        "QUERY": sequence,
    }, timeout=60)
    resp.raise_for_status()
    m = re.search(r"RID = (\S+)", resp.text)
    if not m:
        raise RuntimeError("Error al analizar el RID de QBlast")
    return m.group(1)


def poll_blast(rid: str, poll_interval: int = 30, max_wait: int = 600) -> str:
    """Esperar resultado de BLAST. Devuelve XML al completarse."""
    start = time.time()
    while time.time() - start < max_wait:
        resp = requests.get(BLAST_URL, params={"CMD": "Get", "RID": rid, "FORMAT_OBJECT": "SearchInfo"}, timeout=30)
        if "Status=READY" in resp.text:
            xml_resp = requests.get(BLAST_URL, params={"CMD": "Get", "RID": rid, "FORMAT_TYPE": "XML"}, timeout=60)
            xml_resp.raise_for_status()
            return xml_resp.text
        elif "Status=FAILED" in resp.text:
            raise RuntimeError(f"Fallo de BLAST RID={rid}")
        time.sleep(poll_interval)
    raise TimeoutError(f"BLAST timeout RID={rid}")

# El wrapper de herramienta MCP sigue el mismo patrón que los servidores UniProt y PubMed anteriores. Omiso por espacio.

"""bio_agent.py — Agente Claude + orquestación de múltiples servidores MCP."""
import asyncio
from contextlib import AsyncExitStack

import anthropic
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client


class BioMCPAgent:
    """Agente Claude que coordina múltiples servidores MCP."""

    def __init__(self, model: str = "claude-sonnet-4-5", max_turns: int = 20):
        self.anthropic = anthropic.Anthropic()
        self.model = model
        self.max_turns = max_turns
        self.sessions: dict[str, ClientSession] = {}
        self.all_tools: list[dict] = []
        self._exit_stack: AsyncExitStack | None = None

    async def connect_server(self, name: str, command: str, args: list[str]) -> None:
        """Conecta un servidor MCP. Inicia proceso y obtiene lista de herramientas."""
        params = StdioServerParameters(command=command, args=args)
        stdio_transport = await self._exit_stack.enter_async_context(stdio_client(params))
        session = await self._exit_stack.enter_async_context(ClientSession(*stdio_transport))
        await session.initialize()
        tools_result = await session.list_tools()
        # Convertir al esquema de uso de herramienta de Claude
        for tool in tools_result.tools:
            self.all_tools.append({
                "name": f"{name}__{tool.name}",  # Prefijo del nombre del servidor para evitar conflictos
                "description": tool.description,
                "input_schema": tool.inputSchema,
            })
            self.sessions[f"{name}__{tool.name}"] = session

    async def __aenter__(self):
        self._exit_stack = AsyncExitStack()
        await self._exit_stack.__aenter__()
        return self

    async def __aexit__(self, exc_type, exc_val, exc_tb):
        await self._exit_stack.__aexit__(exc_type, exc_val, exc_tb)

    async def run(self, user_query: str, system_prompt: str) -> dict:
        """Bucle autónomo. Claude repite hasta que stop_reason='end_turn'."""
        messages = [{"role": "user", "content": user_query}]
        tool_log = []

        for turn in range(self.max_turns):
            response = self.anthropic.messages.create(
                model=self.model,
                max_tokens=4096,
                system=system_prompt,
                tools=self.all_tools,
                messages=messages,
            )
            messages.append({"role": "assistant", "content": response.content})

            if response.stop_reason == "end_turn":
                break
            if response.stop_reason != "tool_use":
                continue

            # Procesar bloque tool_use
            tool_results = []
            for block in response.content:
                if block.type != "tool_use":
                    continue
                session = self.sessions.get(block.name)
                if session is None:
                    tool_results.append({
                        "type": "tool_result",
                        "tool_use_id": block.id,
                        "content": f"Unknown tool: {block.name}",
                        "is_error": True,
                    })
                    continue
                try:
                    # Eliminar prefijo del nombre del servidor MCP y llamar con el nombre original de la herramienta
                    original_name = block.name.split("__", 1)[1]
                    result = await session.call_tool(original_name, block.input)
                    content_text = "\n".join(
                        c.text for c in result.content if hasattr(c, "text")
                    )
                    tool_results.append({
                        "type": "tool_result",
                        "tool_use_id": block.id,
                        "content": content_text[:10000],  # Ahorro de contexto
                    })
                    tool_log.append({
                        "tool": block.name,
                        "input": block.input,
                        "output_preview": content_text[:500],
                    })
                except Exception as e:
                    tool_results.append({
                        "type": "tool_result",
                        "tool_use_id": block.id,
                        "content": f"Error al llamar a la herramienta: {e}",
                        "is_error": True,
                    })
            messages.append({"role": "user", "content": tool_results})

        # Extraer solo el texto final
        final_text = ""
        for block in response.content:
            if hasattr(block, "text"):
                final_text += block.text
        return {"final_answer": final_text, "tool_log": tool_log, "turns": turn + 1}


SYSTEM_PROMPT = """Eres un asistente de investigación en bioinformática.
Comprende las solicitudes del usuario y llama autónomamente a las herramientas MCP necesarias (uniprot__*, pubmed__*, blast__*)
para responder basándote en evidencia.

Principios:
1. No fabriques hechos. Todas las afirmaciones deben estar respaldadas por los resultados de las llamadas a herramientas.
2. Incluye siempre las fuentes (acceso de UniProt, PMID, etc.) junto con la respuesta.
3. Si falla la llamada a la herramienta, intenta una ruta alternativa y también informa al usuario sobre el fallo.
4. Minimiza las llamadas innecesarias a herramientas (ahorro de contexto y costos).
"""


async def main():
    async with BioMCPAgent() as agent:
        await agent.connect_server("uniprot", "python", ["uniprot_mcp_server.py"])
        await agent.connect_server("pubmed", "python", ["pubmed_mcp_server.py"])
        # await agent.connect_server("blast", "python", ["blast_mcp_server.py"])

        result = await agent.run(
            user_query="Resume los principales hallazgos de los 3 artículos más destacados de los últimos 5 años sobre TP53 humano, "
                       "y compáralo con las anotaciones funcionales de UniProt de esta proteína para indicar si hay nuevas perspectivas.",
            system_prompt=SYSTEM_PROMPT,
        )
        print("=== Final Answer ===")
        print(result["final_answer"])
        print(f"\n=== Turns: {result['turns']} ===")
        print(f"=== Tool calls: {len(result['tool_log'])} ===")
        for entry in result["tool_log"]:
            print(f"  - {entry['tool']}: {entry['input']}")


if __name__ == "__main__":
    asyncio.run(main())

"""paper_repro_mcp_server.py — Conjunto de herramientas para reproducir artículos (resumen)."""

# herramienta 1: fetch_paper_pdf — Obtención de PDF mediante DOI (prioridad a acceso abierto)
# herramienta 2: extract_method_section — Extracción del texto de la sección de métodos desde el PDF
# herramienta 3: find_github_repo — Búsqueda de URL de GitHub en el cuerpo del artículo y material complementario
# herramienta 4: clone_repo — git clone (en carpeta sandbox)
# herramienta 5: setup_env — Detección automática de requirements.txt y entorno conda · Intento de instalación
# herramienta 6: run_reproduction — Ejecución del punto de entrada estándar del repositorio (README, setup.py)

# Cada herramienta sigue el mismo patrón MCP que los servidores UniProt y PubMed anteriores.
# Por seguridad, la clonación y ejecución deben realizarse dentro de un contenedor aislado (sandbox Docker).

# skills/bio-research/skill.yaml
name: bio-research
version: 1.0.0
description: Agente autónomo de investigación en bioinformática. Integración de UniProt, PubMed, BLAST y reproducción de artículos.
mcp_servers:
  - name: uniprot
    command: python
    args: [/opt/mcp/uniprot_mcp_server.py]
  - name: pubmed
    command: python
    args: [/opt/mcp/pubmed_mcp_server.py]
  - name: blast
    command: python
    args: [/opt/mcp/blast_mcp_server.py]
  - name: paper_repro
    command: python
    args: [/opt/mcp/paper_repro_mcp_server.py]
system_prompt: |
  Usted es un asistente de investigación en bioinformática. ...