# Context Manager

Sistema local de gestión de contexto para IA, agnóstico al modelo.

**Estado**: PRODUCCIÓN en DECK, CORP, ARCHITECT

## Características

- **Log inmutable**: Tabla de referencia no editable con encadenamiento de hashes (blockchain-style)
- **Gestor de contexto mejorable**: Algoritmos versionados y configurables
- **Reemplaza sistema contexto Anthropic**: Solución independiente y optimizada
- **Sistema de métricas**: Evaluación continua del rendimiento
- **A/B Testing**: Experimentación entre versiones de algoritmos
- **Auto-mejora**: Sugerencias automáticas basadas en métricas
- **9 tablas PostgreSQL**: Arquitectura robusta con log inmutable y gestión de contexto

## Arquitectura

```
┌─────────────────────────────────────────────────────────────────┐
│                    TABLAS NO EDITABLES                          │
│  ┌─────────────────┐                                            │
│  │  immutable_log  │  ← Log de mensajes (blockchain-style)      │
│  │  sessions       │  ← Registro de sesiones                    │
│  └─────────────────┘                                            │
├─────────────────────────────────────────────────────────────────┤
│                    TABLAS EDITABLES                             │
│  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐ │
│  │ context_blocks  │  │    memory       │  │ knowledge_base  │ │
│  │ (bloques ctx)   │  │ (memoria LP)    │  │ (RAG simple)    │ │
│  └─────────────────┘  └─────────────────┘  └─────────────────┘ │
│  ┌─────────────────┐  ┌─────────────────┐                      │
│  │   algorithms    │  │    metrics      │                      │
│  │ (versionados)   │  │ (rendimiento)   │                      │
│  └─────────────────┘  └─────────────────┘                      │
└─────────────────────────────────────────────────────────────────┘
```

## Servidores TZZR

| Servidor | IP | Propósito |
|----------|-----|-----------|
| ARCHITECT | 69.62.126.110 | Desarrollo |
| DECK | 72.62.1.113 | Usuario |
| CORP | 92.112.181.188 | Corporativo |

## Estado de Producción

| Servidor | Estado | BD PostgreSQL | Tablas |
|----------|--------|---------------|--------|
| ARCHITECT | ✓ Activo | PostgreSQL + pgvector | 9 |
| DECK | ✓ Activo | PostgreSQL + pgvector | 9 |
| CORP | ✓ Activo | PostgreSQL + pgvector | 9 |

### Tablas PostgreSQL (9 total)
1. `immutable_log` - Log blockchain-style (no editable)
2. `sessions` - Registro de sesiones
3. `context_blocks` - Bloques de contexto
4. `memory` - Memoria a largo plazo
5. `knowledge_base` - Base de conocimiento RAG
6. `algorithms` - Algoritmos versionados
7. `metrics` - Métricas de rendimiento
8. `experiments` - Experimentos A/B
9. `audit_log` - Auditoría del sistema

## Instalación

```bash
# Clonar
git clone <repo>/context-manager
cd context-manager

# Instalar dependencias
pip install -r requirements.txt

# Inicializar base de datos
python -m src.cli init --database context_manager
```

## Uso básico

### Comandos CLI Disponibles

```bash
# Inicializar base de datos
python -m src.cli init --database context_manager

# Chat interactivo (múltiples proveedores)
python -m src.cli chat --provider anthropic --model claude-sonnet-4-20250514
python -m src.cli chat --provider openai --model gpt-4
python -m src.cli chat --provider ollama --model llama3

# Gestión de contexto
python -m src.cli context-add --block <name> --content <content>
python -m src.cli context-list
python -m src.cli context-remove --block <name>

# Análisis y mejora
python -m src.cli analyze --days 30
python -m src.cli suggest --apply
python -m src.cli experiment --control <id> --treatment <id>

# Verificación de integridad
python -m src.cli verify <session_id>
python -m src.cli health-check
```

### Python API

```python
from src import ContextManager
from src.providers import AnthropicProvider

# Inicializar
manager = ContextManager(
    host="localhost",
    database="context_manager"
)

# Iniciar sesión
session = manager.start_session(
    user_id="user1",
    model_provider="anthropic",
    model_name="claude-sonnet-4-20250514"
)

# Obtener contexto para un mensaje
context = manager.get_context_for_message(
    "¿Cómo configuro el servidor?",
    max_tokens=4000
)

# Usar con proveedor
provider = AnthropicProvider()
response = provider.send_message("¿Cómo configuro el servidor?", context)

# Registrar en log inmutable
manager.log_user_message("¿Cómo configuro el servidor?", context)
manager.log_assistant_message(
    response.content,
    tokens_input=response.tokens_input,
    tokens_output=response.tokens_output
)

# Verificar integridad
result = manager.verify_session_integrity()
assert result["is_valid"]
```

### Mejora de algoritmos

```python
from src.algorithm_improver import AlgorithmImprover

improver = AlgorithmImprover(db)

# Analizar rendimiento
analysis = improver.analyze_algorithm(days=30)
print(f"Calidad promedio: {analysis.avg_quality}")
print(f"Sugerencias: {analysis.suggestions}")

# Crear experimento A/B
experiment_id = improver.create_experiment(
    control_id=current_algorithm_id,
    treatment_id=new_algorithm_id,
    name="Test nuevo algoritmo",
    traffic_split=0.5,
    min_samples=100
)

# Evaluar resultados
result = improver.evaluate_experiment(experiment_id)
print(f"Ganador: {result.winner}")
print(f"Mejora: {result.improvement_pct}%")
```

## Estructura de archivos

```
context-manager/
├── schemas/
│   ├── 00_base.sql              # Tipos y funciones base
│   ├── 01_immutable_log.sql     # Log inmutable (NO editable)
│   ├── 02_context_manager.sql   # Bloques, memoria, conocimiento
│   └── 03_algorithm_engine.sql  # Algoritmos y métricas
├── src/
│   ├── __init__.py
│   ├── models.py                # Modelos de datos
│   ├── database.py              # Conexión PostgreSQL
│   ├── context_selector.py      # Motor de selección
│   ├── algorithm_improver.py    # Sistema de mejora
│   ├── cli.py                   # Interfaz de línea de comandos
│   └── providers/
│       ├── base.py              # Clase base
│       ├── anthropic.py         # Adaptador Anthropic
│       ├── openai.py            # Adaptador OpenAI
│       └── ollama.py            # Adaptador Ollama
├── config/
│   └── default.yaml             # Configuración por defecto
├── tests/
├── requirements.txt
└── README.md
```

## Configuración del algoritmo

```json
{
    "max_tokens": 4000,
    "sources": {
        "system_prompts": true,
        "context_blocks": true,
        "memory": true,
        "knowledge": true,
        "history": true,
        "ambient": true
    },
    "weights": {
        "priority": 0.4,
        "relevance": 0.3,
        "recency": 0.2,
        "frequency": 0.1
    },
    "history_config": {
        "max_messages": 20,
        "summarize_after": 10,
        "include_system": false
    },
    "memory_config": {
        "max_items": 15,
        "min_importance": 30
    },
    "knowledge_config": {
        "max_items": 5,
        "require_keyword_match": true
    }
}
```

## Integridad del log

El log inmutable usa encadenamiento de hashes similar a blockchain:

```
Mensaje 1 → hash1 = SHA256(content1)
Mensaje 2 → hash2 = SHA256(hash1 + content2)
Mensaje 3 → hash3 = SHA256(hash2 + content3)
```

Verificar integridad:
```sql
SELECT * FROM verify_chain_integrity('session-uuid');
```

## Variables de entorno

```bash
PGHOST=localhost
PGPORT=5432
PGDATABASE=context_manager
PGUSER=postgres
PGPASSWORD=

ANTHROPIC_API_KEY=sk-ant-...
OPENAI_API_KEY=sk-...
OLLAMA_HOST=localhost
OLLAMA_PORT=11434
```

## Licencia

MIT