# Medical AI Assistant

Sistema RAG desarrollado como proyecto final de **AI Engineering**.

El proyecto implementa un sistema de Inteligencia Artificial preparado para producción, utilizando recuperación semántica, re-ranking, un agente cíclico con LangGraph, observabilidad mediante LangSmith y Arize Phoenix, y un adaptador MCP para exponer herramientas externas. 

---

# Objetivo

Construir un asistente médico capaz de responder preguntas utilizando artículos científicos de **PubMed**, combinando Retrieval-Augmented Generation (RAG) con un agente basado en LangGraph.

El sistema recupera información desde una base vectorial, prioriza los documentos mediante re-ranking y genera respuestas utilizando un modelo de lenguaje (LLM). 

---

# Arquitectura general

```
Usuario
    │
    ▼
main.py
    │
    ▼
pipeline.py
    │
    ▼
MedicalAIAgent
    │
    ▼
LangGraph
    │
    ├───────────────┐
    ▼               │
Retrieval           │
    ▼               │
Re-ranking          │
    ▼               │
Construcción        │
de contexto         │
    ▼               │
LLM                 │
    ▼               │
Evaluación          │
    │               │
    └──── Retry ◄───┘
    │
    ▼
Respuesta final
```

---

# Estructura del proyecto

```
Medical_AI_Assistant/

├── retrieval/
├── ranking/
├── orquestacion/
├── agente/
├── adaptadores_mcp/
├── observabilidad/
├── despliegue/
├── data/
├── scripts/
├── test/

├── main.py
├── pipeline.py
├── requirements.txt
├── README.md
└── .env.example
```

---

# Tecnologías utilizadas

- Python 3.11
- LangChain
- LangGraph
- Google Gemini
- Sentence Transformers
- CrossEncoder (MS MARCO)
- Qdrant
- LangSmith
- Arize Phoenix
- OpenTelemetry
- MCP (Model Context Protocol)
- Docker
- Kubernetes

---

# Componentes implementados

## Retrieval

- Base vectorial Qdrant
- Embeddings Sentence Transformers
- Recuperación semántica

---

## Ranking

Re-ranking mediante:

```
cross-encoder/ms-marco-MiniLM-L-6-v2
```

---

## Orquestación

Implementada utilizando:

- LangChain

---

## Agente

Implementado mediante:

- LangGraph

Flujo del agente:

```
Retrieval
    ↓
Re-ranking
    ↓
Contexto
    ↓
LLM
    ↓
Evaluación
    ↓
Retry (si es necesario)
```

---

## Observabilidad

Implementada mediante:

- ✅ LangSmith
- ✅ Arize Phoenix (OpenTelemetry)

Permite visualizar la ejecución completa del pipeline, las llamadas al modelo, tiempos de ejecución y trazabilidad del agente.

---

## MCP

Se implementó un servidor MCP utilizando FastMCP.

Herramienta disponible:

```
search_medical_documents()
```

Permite consultar documentos almacenados en Qdrant desde clientes compatibles con Model Context Protocol.

---

## Despliegue

El proyecto incluye:

- Dockerfile
- Kubernetes Deployment
- Kubernetes Service

Los archivos de despliegue están preparados para ejecutarse en un entorno con Docker Engine y un clúster Kubernetes configurado.

---

# Instalación

Crear el entorno:

```bash
conda create -n medical_ai python=3.11
```

Activarlo:

```bash
conda activate medical_ai
```

Instalar dependencias:

```bash
pip install -r requirements.txt
```

---

# Variables de entorno

Crear un archivo `.env`:

```env
GEMINI_API_KEY=

LANGSMITH_TRACING=true
LANGSMITH_API_KEY=
LANGSMITH_PROJECT=medical-ai-assistant

PHOENIX_TRACING=true
PHOENIX_API_KEY=
PHOENIX_COLLECTOR_ENDPOINT=
PHOENIX_PROJECT_NAME=medical-ai-assistant
```

---

# Ejecución

```bash
python main.py
```

---

# Pruebas

Grafo:

```bash
python test/test_graph.py
```

Servidor MCP:

```bash
python test/test_mcp.py
```

Prueba del LLM:

```bash
python test/test_llm.py
```

Prueba de Gemini:

```bash
python test/test_gemini.py
```

---

# Estado de implementación

| Componente | Estado |
|------------|--------|
| Retrieval | ✅ |
| Ranking | ✅ |
| LangChain | ✅ |
| LangGraph | ✅ |
| MCP | ✅ |
| LangSmith | ✅ |
| Arize Phoenix | ✅ |
| Docker | ✅ |
| Kubernetes | ✅ |

---

# Autor

**Gonzalo Matos**

Proyecto desarrollado como trabajo final de la asignatura **AI Engineering**.

El repositorio implementa una arquitectura modular basada en Retrieval-Augmented Generation (RAG), LangChain, LangGraph, Model Context Protocol (MCP) y herramientas de observabilidad para sistemas de IA en producción.