Jan AI: el ChatGPT open source que corre 100% offline en tu PC (2026)

¿Qué es Jan?

Jan es una alternativa open source a ChatGPT que corre 100% offline en tu computadora. Es una aplicación de escritorio que te permite descargar y ejecutar modelos de lenguaje (LLMs) localmente, con total privacidad y control, pero también conectarse a modelos en la nube como GPT, Claude, Gemini y otros cuando lo necesites.

Con más de 4 millones de descargas y 43.2K estrellas en GitHub, Jan se ha posicionado como la opción más limpia y privacy-first para quienes quieren una experiencia tipo ChatGPT sin enviar sus datos a servidores de terceros. No requiere cuenta, no tiene telemetría por defecto, y su código es completamente auditable.

¿Qué problema resuelve Jan?

Si usas ChatGPT, Claude o Gemini, estás enviando cada conversación a servidores que no controlas. Para muchos casos eso es aceptable, pero para otros no:

• Privacidad: Conversaciones sensibles (legal, médico, financiero, código propietario) que no deberían salir de tu máquina
• Offline: Trabajar sin conexión a internet — en un avión, en una cabaña, en un entorno air-gapped
• Coste: Conversaciones ilimitadas gratis, sin suscripción mensual ni facturación por token
• Control: Elegir exactamente qué modelo corre, con qué parámetros, y qué datos salen o no salen
• Vendor lock-in: No depender de un único proveedor. Cambiar entre modelos locales y cloud con un clic

Jan resuelve todo esto en una app de escritorio con una interfaz pulida, sin necesidad de tocar la terminal.

Características principales

1. Modelos locales 100% offline

Jan usa llama.cpp como motor de inferencia y soporta el formato GGUF, optimizado para hardware de consumo. Descargas modelos desde el Hub integrado y chateas sin conexión. Tus conversaciones nunca salen de tu dispositivo.

Modelos disponibles: Llama, Gemma, Qwen, GPT-OSS, DeepSeek, Mistral, Phi y cientos más desde HuggingFace.

2. Integración con modelos en la nube

Jan no te limita a modelos locales. Puedes conectar tu API key de cualquier proveedor major y usar modelos frontier desde la misma interfaz:

Proveedor	Modelos destacados
OpenAI	GPT-4o, o3, o1, GPT-4 Turbo, GPT-3.5
Anthropic	Claude Opus 4, Claude Sonnet 4, Claude Haiku 3.5
Google	Gemini 2.0 Pro, Flash
Mistral AI	Mistral Large, Medium
Groq	Inferencia ultra-rápida para Llama, Mixtral
Cohere	Command models
HuggingFace	Serverless Inference API
OpenRouter	Acceso a 400+ modelos con una sola API key
Cualquier endpoint OpenAI-compatible	Together AI, DeepSeek, Fireworks, Perplexity, vLLM, llama-server propio

Esto significa que puedes usar OpenRouter dentro de Jan para acceder a 400+ modelos, o conectar tu GLM-5.2 vía el endpoint de Z.ai, todo desde la misma app.

3. Asistentes personalizados

Jan te permite crear asistentes especializados para diferentes tareas. Cada asistente tiene su propio system prompt, parámetros de generación (temperature, max tokens, context length) y modelo asignado. Por ejemplo:

• Un asistente de programación con Qwen Coder y temperature baja
• Un asistente de escritura creativa con Llama y temperature alta
• Un asistente de análisis con Claude Opus vía Anthropic API
• Un asistente de investigación con DeepSeek R1 local

4. API local compatible con OpenAI

Jan incluye un servidor API que replica la API de OpenAI en http://localhost:1337/v1. Esto permite que cualquier herramienta compatible con OpenAI use tus modelos locales:

# Activar: Settings → Local API Server → Start Server

# Test con curl
curl http://127.0.0.1:1337/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer secret-key-123" \
  -d '{
    "model": "YOUR_MODEL_ID",
    "messages": [{"role": "user", "content": "Cuéntame un chiste"}]
  }'

Compatible con: Continue.dev, SillyTavern, LangChain, Claude Code, scripts de Python, y cualquier cliente que hable OpenAI.

5. Model Context Protocol (MCP)

Jan soporta MCP, el estándar abierto que permite a los modelos de IA interactuar con herramientas externas y fuentes de datos. Jan actúa como MCP host, permitiéndote conectar servidores MCP para:

• Productividad: Linear, Todoist, Notion, Google Sheets
• Búsqueda web: Serper, Exa, Browser MCP
• Análisis de datos: Jupyter, E2B
• Diseño: Canva
• Codebase local: Filesystem, GitHub
• APIs custom: Cualquier servidor MCP de la comunidad

Para usar MCP efectivamente, necesitas un modelo con capacidades de tool calling. Los recomendados son Claude Opus 4, Claude Sonnet 4, GPT-4, y Gemini 2.0 Pro.

6. Privacidad first

Jan fue diseñado desde cero con privacidad como prioridad:

• Sin telemetría por defecto: No envía datos de uso a ningún servidor
• Sin cuenta requerida: Descargas, instalas y usas sin registro
• Conversaciones locales: Todo el historial se almacena en tu dispositivo
• Código auditable: Apache 2.0, puedes inspeccionar every línea
• Modelos offline: Cuando usas modelos locales, cero datos salen

7. Memory (próximamente)

Jan está desarrollando una feature de memoria persistente: tu contexto y preferencias se mantienen entre conversaciones, así no tienes que repetirte. Jan recordará cosas como tu estilo de comunicación, proyectos en curso, y preferencias de respuesta.

Requisitos del sistema

Plataforma	Requisito	GPU
macOS	13.6+ (Apple Silicon o Intel)	Metal (Apple Silicon nativo)
Windows	Windows 10+	CUDA (NVIDIA), Vulkan (AMD/Intel Arc)
Linux	La mayoría de distros (x86_64 y Arm64)	CUDA, Vulkan, o CPU fallback

RAM según tamaño de modelo

Tamaño de modelo	RAM mínima	Ejemplo
3B parámetros	8 GB	Jan v1, Phi-3, Qwen 2.5 3B
7B parámetros	16 GB	Llama 3.3 8B, Qwen 2.5 7B, Gemma 2 9B
13B+ parámetros	32 GB	Qwen 2.5 14B, Mistral 12B

Jan detecta automáticamente tu hardware y usa GPU cuando está disponible — CUDA en NVIDIA, Metal en Apple Silicon, Vulkan en AMD/Intel Arc, o CPU como fallback. No necesitas seleccionar el backend manualmente.

Cómo instalar Jan — paso a paso

Paso 1: Descargar Jan

Ve a jan.ai o a los releases de GitHub y descarga el instalador para tu plataforma:

Plataforma	Archivo	Notas
macOS	jan.dmg	DMG firmado, arrastrar a Applications
Windows	jan.exe	MSI installer, no requiere admin
Linux (deb)	jan.deb	sudo dpkg -i jan-linux-amd64.deb
Linux (AppImage)	jan.AppImage	Más ligero, sin instalación
Linux (Arm64)	Ver how-to en docs	Para Raspberry Pi, Ampere, etc.

Paso 2: Descargar tu primer modelo

Abre Jan y ve a la pestaña Hub en el sidebar izquierdo. Verás modelos curados con descarga en un clic:

1. Busca o navega los modelos disponibles
2. Jan indica si un modelo será "Slow on your device" o si no tienes suficiente RAM
3. Haz clic en Download en tu modelo elegido
4. Los modelos se guardan en ~/jan/models/

Recomendación para empezar: Jan v1 (4B parámetros, ~2.5GB) está optimizado para razonamiento y tool calling, y corre fluido en la mayoría del hardware.

Importar modelos desde HuggingFace

Si buscas un modelo específico que no está en el Hub curado:

1. Ve a huggingface.co/models y encuentra un modelo GGUF
2. Copia el model ID (ej: TheBloke/Mistral-7B-v0.1-GGUF)
3. Pégalo en la barra de búsqueda del Hub de Jan
4. Selecciona la quantización preferida y descarga

Algunos modelos requieren un HuggingFace Access Token. Añádelo en Settings → Model Providers → Hugging Face.

Importar archivos GGUF locales

Si ya tienes archivos GGUF descargados:

1. Ve a Settings → Model Providers → Llama.cpp
2. Haz clic en Import y selecciona tu archivo .gguf
3. Elige: Link Files (symlinks, ahorra espacio) o Duplicate (copia, más seguro para discos externos)
4. Haz clic en Import

Paso 3: Iniciar tu primera conversación

1. Ve a Threads en el sidebar
2. Haz clic en New Chat
3. Selecciona tu modelo descargado desde el model picker en la parte superior
4. Escribe tu primer mensaje

El primer prompt tiene un cold start de 5-10 segundos mientras el modelo se carga en RAM/GPU. Después, el chat es responsivo.

Paso 4: Personalizar settings del chat

Haz clic en el icono de engranaje en el panel de chat para ajustar:

• System prompt: Instrucciones para el modelo
• Temperature: 0.7 por defecto; baja (0.3) para respuestas precisas, alta (1.0+) para creatividad
• Max tokens: 4096 por defecto; sube para generación larga
• Context length: Depende del modelo
• Top-p, top-k, repetition penalty: Control fino de sampling

Paso 5: Activar el API local

1. Ve a Settings → Local API Server
2. Haz clic en Start Server
3. El servidor está listo cuando veas JAN API listening at http://127.0.0.1:1337

Configuración del servidor:

• Host: 127.0.0.1 (default, solo tu máquina) o 0.0.0.0 (red local)
• Puerto: 1337 por defecto, configurable
• API Key: Debes setear una. Cualquier string funciona (ej: secret-key-123)
• CORS: Habilitado por defecto para apps web

Paso 6: Conectar modelos en la nube

1. Ve a Settings → Model Providers
2. Selecciona el proveedor (OpenAI, Anthropic, Google, etc.)
3. Pega tu API key
4. Guarda
5. Los modelos del proveedor aparecerán en el model picker

Para endpoints OpenAI-compatible custom (Together AI, DeepSeek, OpenRouter, tu propio servidor):

1. Settings → Model Providers → OpenAI
2. Activa Custom Endpoint
3. Ingresa tu URL (ej: https://openrouter.ai/api/v1)
4. Añade tu API key
5. Configura los modelos disponibles

Paso 7: Activar MCP para capacidades agénticas

1. Ve a Settings → General → Advanced y activa experimental features
2. Ve a Settings → MCP Servers y activa Allow All MCP Tool Permission
3. Haz clic en + para añadir un servidor MCP
4. Configura comando y argumentos (ej: Browser MCP, Filesystem, etc.)
5. Verifica que el servidor muestre "Connected"
6. Usa un modelo con tool calling (Claude, GPT-4, Gemini) en tu chat

Casos de uso

1. Programación con IA local

Usa modelos como Qwen 2.5 Coder o GPT-OSS 120B para programación, debugging y code review — todo offline, sin enviar tu código a ningún servidor. Combina con el API local en localhost:1337 para usarlo con Continue.dev en VS Code.

2. Investigación y análisis offline

Carga DeepSeek R1 o Llama 4 para investigación profunda, análisis de documentos y generación de contenido. Perfecto para entornos sin conexión o cuando trabajas con datos confidenciales.

3. Datos sensibles (legal, médico, financiero)

Procesa documentos confidenciales localmente sin exponerlos a la nube. Jan es ideal para abogados, médicos y financieros que manejan información protegida. Cero telemetría, cero data leaving.

4. Desarrollo de aplicaciones con IA

Usa el API local (localhost:1337) para construir y testear aplicaciones con IA sin coste de API. Drop-in replacement para OpenAI — solo cambia el base_url. Ideal para desarrollo y staging.

5. Asistente personal con memoria

Crea asistentes personalizados para diferentes áreas de tu vida: uno para programación, otro para escritura, otro para investigación. Con la feature de Memory en camino, Jan recordará tu contexto entre sesiones.

6. Agente con MCP

Conecta Claude Opus 4 vía Anthropic API con servidores MCP para un agente que puede buscar en la web, acceder a Notion, consultar bases de datos, y automatizar tareas — todo orquestado desde la interfaz de Jan.

Jan vs LM Studio vs Ollama

Característica	Jan	LM Studio	Ollama
Licencia	Apache 2.0 (open source)	Propietario (gratis personal)	MIT (open source)
Telemetría	No por defecto	Mínima	No
Interfaz	GUI de escritorio	GUI de escritorio (más pulida)	CLI + GUI vía Open WebUI
Modelos locales	GGUF (llama.cpp)	GGUF + MLX	GGUF (llama.cpp)
API local	localhost:1337 (OpenAI-compatible)	localhost:1234 (OpenAI-compatible)	localhost:11434 (OpenAI-compatible)
Modelos cloud	Sí (OpenAI, Anthropic, Google, etc.)	Sí (OpenAI, Anthropic, etc.)	No nativo
MCP	Sí	Sí	Vía integraciones
Headless / servidor	No (requiere GUI abierta)	Sí (llmster)	Sí (systemd nativo)
Asistentes custom	Sí	Sí	Vía Modelfile
Mejor para	Privacidad total + cloud en una app	UX pulida + headless daemon	Servidor ligero + Docker

Integración con el ecosistema de IA

Con Claude Code

Puedes usar el API local de Jan (localhost:1337) como backend para Claude Code, igual que harías con LM Studio. Configura ANTHROPIC_BASE_URL apuntando a Jan y tendrás un agente de programación offline.

Con OpenRouter

Conecta OpenRouter como endpoint custom en Jan para acceder a 400+ modelos desde la misma interfaz. Una sola API key, failover automático, y la comodidad de la GUI de Jan.

Con GLM-5.2

Usa GLM-5.2 dentro de Jan de dos formas: como modelo local (descargando el GGUF) o vía el endpoint de Z.ai como custom OpenAI-compatible. Con 1M de contexto y licencia MIT, es el modelo open source más cercano a Claude Opus.

Con LM Studio y Ollama

Jan coexiste perfectamente con LM Studio y Ollama. Cada uno ocupa un puerto distinto (Jan: 1337, LM Studio: 1234, Ollama: 11434), así puedes tener los tres corriendo simultáneamente y elegir el mejor para cada tarea.

Con Hermes Agent y OpenClaw

Tanto Hermes Agent como OpenClaw pueden configurarse para usar el API local de Jan como proveedor de modelos. Esto da a tus agentes IA un backend local y privado.

Con Supabase self-hosted

Si tienes Supabase self-hosted en tu VPS, puedes usar Jan como frontend local para interactuar con modelos que consultan tu base de datos vía MCP — un stack completo de IA privada de extremo a extremo.

Modelos recomendados para Jan

Modelo	Tamaño	RAM mínima	Ideal para
Jan v1	4B	8 GB	Empezar, razonamiento, tool calling
Qwen 2.5 Coder 7B	7B	16 GB	Programación, debugging
Llama 3.3 8B	8B	16 GB	Uso general, chat
Gemma 2 9B	9B	16 GB	Razonamiento, escritura
DeepSeek R1	7B-14B	16-32 GB	Investigación, reasoning profundo
GPT-OSS 120B	120B	64+ GB	Máxima calidad local (requiere hardware potente)
GLM-5.2 (vía Z.ai)	Cloud	—	1M contexto, coding agéntico, open source

Solución de problemas

El modelo carga muy lento

El primer prompt tiene un cold start de 5-10 segundos mientras el modelo se carga en memoria. Si es persistentemente lento, verifica que tu GPU esté siendo usada (Jan lo detecta automáticamente, pero revisa Settings → Hardware).

"Not enough RAM"

El modelo que intentas cargar excede tu RAM disponible. Jan muestra esta advertencia en el Hub. Usa un modelo más pequeño o una quantización más agresiva (Q4_K_M en lugar de Q8).

El API local no responde

Verifica que el servidor esté activo en Settings → Local API Server. Comprueba que el modelo esté cargado (abre un chat con él). El API usa el modelo actualmente cargado en Jan — la app debe estar abierta.

Error de HuggingFace Access Token

Algunos modelos requieren un token de HuggingFace. Ve a Settings → Model Providers → Hugging Face y añade tu token. Crea uno gratis en huggingface.co/settings/tokens.

MCP no funciona

Asegúrate de que el modelo soporta tool calling. Para modelos cloud, habilita Tools en Settings → Model Providers → [Provider] → botón +. Para modelos locales, habilita tool calling en Model Capabilities.

Cuándo NO usar Jan

• Servidor headless 24/7: El API de Jan requiere la app GUI abierta. Para un servidor puro, usa Ollama como systemd o llmster de LM Studio
• MLX en Apple Silicon: LM Studio tiene mejor soporte MLX nativo para Macs con M-series
• Deploy en Docker: Ollama es más Docker-friendly y ligero para contenedores
• Inferencia a escala en producción: Para alta concurrencia, usa vLLM o TGI

Conclusión

Jan es, para muchos usuarios, el punto dulce entre privacidad, flexibilidad y facilidad de uso. No es tan pulido como LM Studio ni tan ligero como Ollama, pero ofrece algo que ninguno de los dos combina: open source real (Apache 2.0), cero telemetría, modelos locales y cloud en una sola app, y MCP integrado.

Si tu prioridad es la privacidad — conversaciones que nunca salen de tu máquina, código que puedes auditar, sin cuenta ni registro — Jan es la opción más limpia. Y cuando necesites modelos frontier, conectas tu API key de Anthropic, OpenAI o OpenRouter sin cambiar de app.

Para un stack completo de IA privada, combina Jan con Claude Code para programación agéntica, GLM-5.2 para máxima capacidad, Hermes Agent para orquestación, OpenClaw para tu asistente IA, y Supabase self-hosted para el backend. Todo open source, todo bajo tu control.