¿Por Qué Construir un Servidor Privado de AI?
Enviar datos sensibles a APIs de AI de terceros como OpenAI, Anthropic o Google introduce riesgos que muchas organizaciones no pueden aceptar. Un servidor AI privado mantiene cada byte de datos bajo tu control, en hardware que posees o alquilas exclusivamente, con cero llamadas a APIs externas.
Soberanía de Datos
Tus prompts, documentos y resultados del modelo nunca salen de tu infraestructura. Sin registro de terceros, sin entrenamiento con tus datos, sin riesgo de fugas de datos a través de endpoints API que no controlas.
Cumplimiento Normativo
Cumple con los requisitos de GDPR, HIPAA, SOC 2 y regulaciones específicas del sector manteniendo el procesamiento AI dentro de tu perímetro de datos. Sin preocupaciones por transferencia de datos transfronteriza.
Previsibilidad de Costes
Coste mensual fijo independientemente del uso. Sin sorpresas en la facturación por token, sin cambios repentinos en los límites de velocidad, sin aumentos de precios de los proveedores de API. Ejecuta inferencia ilimitada 24/7 a tarifa plana.
Sin Límites de Velocidad
Procesa tantas solicitudes como tu hardware pueda manejar. Sin límites de tokens por minuto, sin cola de solicitudes del lado del proveedor, sin rendimiento degradado durante las horas pico.
El Riesgo de las APIs en la Nube: Cuando envías datos a un proveedor de AI en la nube, pierdes el control. Incluso con garantías contractuales, tus datos atraviesan redes que no gestionas, residen en servidores que no controlas y están sujetos a la postura de seguridad del proveedor. Para industrias reguladas (sanidad, finanzas, legal, defensa), esto suele ser un impedimento.
¿Por Qué Mac Mini M4? La arquitectura de memoria unificada de Apple Silicon te permite ejecutar modelos de 7B-70B parámetros en un solo dispositivo que consume menos de 15W de potencia. El ancho de banda de memoria del M4 (hasta 120 GB/s) alimenta los pesos del modelo al GPU de forma eficiente, entregando 30-40 tokens/segundo para modelos de 7B, suficientemente rápido para chat en tiempo real. A partir de $85/mes (USD, sin impuestos), tienes un Mac físico asignado 1:1, nunca virtualizado, sin hardware que comprar por adelantado y sin compromiso.
Visión General de la Arquitectura
El stack del servidor AI privado consta de cinco capas, todas ejecutándose localmente en tu Mac Mini M4. No se requieren servicios externos.
Arquitectura del Sistema
Clientes
Navegador Web / Consumidores de API / Apps Móviles
Proxy Inverso nginx
Terminación SSL/TLS + Limitación de Velocidad + Autenticación
Open WebUI
Interfaz de Chat (Puerto 3000)
Pipeline RAG
FastAPI + LangChain (Puerto 8000)
Ollama
Motor de Inferencia LLM (Puerto 11434): Llama 3, Mistral, CodeLlama
ChromaDB
Base de Datos Vectorial (Puerto 8200)
# Port mapping summary for the full stack:
#
# Port 443 - nginx (HTTPS, public-facing)
# Port 80 - nginx (HTTP, redirects to HTTPS)
# Port 11434 - Ollama (LLM inference, internal only)
# Port 3000 - Open WebUI (chat interface, proxied via nginx)
# Port 8000 - RAG API (FastAPI, proxied via nginx)
# Port 8200 - ChromaDB (vector database, internal only)
# Port 51820 - WireGuard VPN (optional, for remote access)
Paso 1: Configuración del Servidor
Comienza aprovisionando tu Mac Mini M4 y configurando el acceso remoto seguro. Si usas My Remote Mac, el acceso SSH se proporciona de serie.
Configuración SSH
# Connect to your Mac Mini M4 via SSH
ssh admin@your-mac-mini.myremotemac.com
# Generate an SSH key pair (if you don't have one)
ssh-keygen -t ed25519 -C "ai-server-admin" -f ~/.ssh/id_ai_server
# Copy your public key to the server
ssh-copy-id -i ~/.ssh/id_ai_server.pub admin@your-mac-mini.myremotemac.com
# Configure SSH client for easier access
cat <<EOF >> ~/.ssh/config
Host ai-server
HostName your-mac-mini.myremotemac.com
User admin
IdentityFile ~/.ssh/id_ai_server
ForwardAgent no
ServerAliveInterval 60
ServerAliveCountMax 3
EOF
# Now connect with just:
ssh ai-server
Actualizaciones del Sistema y Preparación
# Update macOS to latest version
sudo softwareupdate --install --all --agree-to-license
# Homebrew comes preinstalled: put it on your PATH (once per account)
echo 'eval "$(/opt/homebrew/bin/brew shellenv)"' >> ~/.zprofile
eval "$(/opt/homebrew/bin/brew shellenv)"
# Install essential tools
brew install wget curl jq htop python@3.12 git
# Create a dedicated directory for AI services
mkdir -p ~/ai-server/{models,data,logs,config}
mkdir -p ~/ai-server/rag/{documents,vectorstore}
# Set up Python virtual environment for AI tools
python3.12 -m venv ~/ai-server/venv
source ~/ai-server/venv/bin/activate
pip install --upgrade pip setuptools wheel
Crear un Usuario de Servicio Dedicado (Opcional)
# Create a dedicated user for AI services (principle of least privilege)
sudo dscl . -create /Users/aiservice
sudo dscl . -create /Users/aiservice UserShell /bin/zsh
sudo dscl . -create /Users/aiservice RealName "AI Service Account"
sudo dscl . -create /Users/aiservice UniqueID 550
sudo dscl . -create /Users/aiservice PrimaryGroupID 20
sudo dscl . -create /Users/aiservice NFSHomeDirectory /Users/aiservice
sudo mkdir -p /Users/aiservice
sudo chown aiservice:staff /Users/aiservice
# Grant access to the AI server directory
sudo chown -R aiservice:staff ~/ai-server
Paso 2: Instalar Ollama y Modelos
Ollama es la columna vertebral de tu servidor AI privado. Gestiona la descarga de modelos, la cuantización y proporciona una API compatible con OpenAI, todo ejecutándose localmente con cero llamadas externas.
Instalar Ollama
# Install Ollama with its official script (on macOS it installs
# /Applications/Ollama.app and links the ollama command in /usr/local/bin)
# OLLAMA_NO_START=1 skips opening the desktop app: it needs a GUI session
# and would hold port 11434, which the launchd service below uses
curl -fsSL https://ollama.com/install.sh | OLLAMA_NO_START=1 sh
# Verify installation
ollama --version
# Start a temporary Ollama server for the next step (localhost:11434)
ollama serve &
Descargar Modelos para Diferentes Casos de Uso
# General-purpose assistant (recommended starting point)
ollama pull llama3:8b # 4.7 GB - fits 16GB RAM
# Instruction-following and reasoning
ollama pull mistral:7b # 4.1 GB - excellent for RAG
# Code generation and analysis
ollama pull codellama:7b # 3.8 GB - code-specific model
ollama pull codellama:13b # 7.4 GB - better code quality (needs 24GB)
# Embedding model for RAG pipeline
ollama pull nomic-embed-text # 274 MB - text embeddings
# Verify all models are downloaded
ollama list
# NAME SIZE MODIFIED
# llama3:8b 4.7 GB 2 minutes ago
# mistral:7b 4.1 GB 5 minutes ago
# codellama:7b 3.8 GB 8 minutes ago
# nomic-embed-text 274 MB 10 minutes ago
# Test a model interactively
ollama run llama3:8b "What are the benefits of self-hosted AI?"
Configurar Ollama como Servicio Persistente
# Create a LaunchAgent: Ollama starts with your user session and restarts
# if it crashes (enable automatic login so it also returns after a reboot)
cat <<'EOF' > ~/Library/LaunchAgents/com.ollama.server.plist
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
"http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>Label</key>
<string>com.ollama.server</string>
<key>ProgramArguments</key>
<array>
<string>/usr/local/bin/ollama</string>
<string>serve</string>
</array>
<key>EnvironmentVariables</key>
<dict>
<key>OLLAMA_HOST</key>
<string>127.0.0.1:11434</string>
<key>OLLAMA_KEEP_ALIVE</key>
<string>-1</string>
<key>OLLAMA_NUM_PARALLEL</key>
<string>4</string>
</dict>
<key>RunAtLoad</key>
<true/>
<key>KeepAlive</key>
<true/>
<key>StandardOutPath</key>
<string>/Users/admin/ai-server/logs/ollama.log</string>
<key>StandardErrorPath</key>
<string>/Users/admin/ai-server/logs/ollama-error.log</string>
</dict>
</plist>
EOF
# Stop the temporary server from "Install Ollama" so the service can use port 11434
pkill -f "ollama serve" || true
# Load the service
launchctl load ~/Library/LaunchAgents/com.ollama.server.plist
# Verify Ollama is running
curl -s http://localhost:11434/api/tags | jq '.models[].name'
# "llama3:8b"
# "mistral:7b"
# "codellama:7b"
# "nomic-embed-text"
Importante: Observa que OLLAMA_HOST está configurado a 127.0.0.1:11434 (solo localhost). Esto asegura que Ollama no sea accesible directamente desde la red. Todo el acceso externo pasará por el proxy inverso nginx configurado en el Paso 5.
Paso 3: Construir un Pipeline RAG
La Generación Aumentada por Recuperación (RAG) permite que tu AI responda preguntas basándose en tus propios documentos (wikis de empresa, contratos legales, documentación técnica) sin enviar ninguno de esos datos a un proveedor en la nube. Aquí construimos un pipeline RAG completo con ChromaDB y LangChain.
Instalar Dependencias
# Activate the virtual environment
source ~/ai-server/venv/bin/activate
# Install RAG pipeline dependencies
pip install \
langchain==0.1.20 \
langchain-community==0.0.38 \
langchain-chroma==0.1.0 \
chromadb==0.4.24 \
sentence-transformers==2.7.0 \
pypdf==4.2.0 \
docx2txt==0.8 \
fastapi==0.111.0 \
uvicorn==0.29.0 \
python-multipart==0.0.9 \
pydantic==2.7.1
Pipeline de Ingesta de Documentos
# ~/ai-server/rag/ingest.py
"""
Document ingestion pipeline for the private RAG system.
Loads PDFs, DOCX, and text files, splits them into chunks,
generates embeddings via Ollama, and stores them in ChromaDB.
"""
import os
import sys
from pathlib import Path
from langchain_community.document_loaders import (
PyPDFLoader,
Docx2txtLoader,
TextLoader,
DirectoryLoader,
)
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.embeddings import OllamaEmbeddings
from langchain_chroma import Chroma
# Configuration
DOCUMENTS_DIR = os.path.expanduser("~/ai-server/rag/documents")
VECTORSTORE_DIR = os.path.expanduser("~/ai-server/rag/vectorstore")
OLLAMA_BASE_URL = "http://localhost:11434"
EMBEDDING_MODEL = "nomic-embed-text"
CHUNK_SIZE = 1000
CHUNK_OVERLAP = 200
def load_documents(directory: str):
"""Load all supported document types from a directory."""
documents = []
path = Path(directory)
# Load PDFs
for pdf_file in path.glob("**/*.pdf"):
loader = PyPDFLoader(str(pdf_file))
documents.extend(loader.load())
print(f" Loaded: {pdf_file.name} ({len(loader.load())} pages)")
# Load DOCX files
for docx_file in path.glob("**/*.docx"):
loader = Docx2txtLoader(str(docx_file))
documents.extend(loader.load())
print(f" Loaded: {docx_file.name}")
# Load text files
for txt_file in path.glob("**/*.txt"):
loader = TextLoader(str(txt_file))
documents.extend(loader.load())
print(f" Loaded: {txt_file.name}")
# Load markdown files
for md_file in path.glob("**/*.md"):
loader = TextLoader(str(md_file))
documents.extend(loader.load())
print(f" Loaded: {md_file.name}")
return documents
def create_vectorstore(documents):
"""Split documents into chunks and store embeddings in ChromaDB."""
# Split documents into chunks
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=CHUNK_SIZE,
chunk_overlap=CHUNK_OVERLAP,
length_function=len,
separators=["\n\n", "\n", ". ", " ", ""],
)
chunks = text_splitter.split_documents(documents)
print(f"\nSplit {len(documents)} documents into {len(chunks)} chunks")
# Create embeddings using Ollama (runs locally!)
embeddings = OllamaEmbeddings(
model=EMBEDDING_MODEL,
base_url=OLLAMA_BASE_URL,
)
# Store in ChromaDB
vectorstore = Chroma.from_documents(
documents=chunks,
embedding=embeddings,
persist_directory=VECTORSTORE_DIR,
collection_name="private_docs",
)
print(f"Stored {len(chunks)} chunks in ChromaDB at {VECTORSTORE_DIR}")
return vectorstore
if __name__ == "__main__":
print("=== Private RAG Document Ingestion ===\n")
print(f"Loading documents from: {DOCUMENTS_DIR}")
docs = load_documents(DOCUMENTS_DIR)
print(f"\nTotal documents loaded: {len(docs)}")
if not docs:
print("No documents found. Add files to ~/ai-server/rag/documents/")
sys.exit(1)
print("\nCreating vector store...")
create_vectorstore(docs)
print("\nIngestion complete!")
API de Consulta RAG
# ~/ai-server/rag/api.py
"""
RAG Query API - FastAPI service for document Q&A.
Retrieves relevant chunks from ChromaDB and generates
answers using Ollama. Everything runs locally.
"""
from fastapi import FastAPI, UploadFile, File, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel
from typing import Optional, List
import os
import shutil
from langchain_community.embeddings import OllamaEmbeddings
from langchain_chroma import Chroma
from langchain_community.llms import Ollama
from langchain.chains import RetrievalQA
from langchain.prompts import PromptTemplate
# Configuration
VECTORSTORE_DIR = os.path.expanduser("~/ai-server/rag/vectorstore")
DOCUMENTS_DIR = os.path.expanduser("~/ai-server/rag/documents")
OLLAMA_BASE_URL = "http://localhost:11434"
EMBEDDING_MODEL = "nomic-embed-text"
LLM_MODEL = "mistral:7b"
app = FastAPI(
title="Private RAG API",
description="Self-hosted document Q&A with zero cloud dependencies",
version="1.0.0",
)
app.add_middleware(
CORSMiddleware,
allow_origins=["*"],
allow_methods=["*"],
allow_headers=["*"],
)
# Initialize components
embeddings = OllamaEmbeddings(
model=EMBEDDING_MODEL,
base_url=OLLAMA_BASE_URL,
)
vectorstore = Chroma(
persist_directory=VECTORSTORE_DIR,
embedding_function=embeddings,
collection_name="private_docs",
)
llm = Ollama(
model=LLM_MODEL,
base_url=OLLAMA_BASE_URL,
temperature=0.3,
num_ctx=4096,
)
# Custom prompt template
PROMPT_TEMPLATE = """Use the following context to answer the question.
If you cannot find the answer in the context, say "I don't have enough
information in the provided documents to answer this question."
Context:
{context}
Question: {question}
Answer:"""
prompt = PromptTemplate(
template=PROMPT_TEMPLATE,
input_variables=["context", "question"],
)
qa_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=vectorstore.as_retriever(
search_type="similarity",
search_kwargs={"k": 4},
),
chain_type_kwargs={"prompt": prompt},
return_source_documents=True,
)
class QueryRequest(BaseModel):
question: str
model: Optional[str] = "mistral:7b"
num_results: Optional[int] = 4
class QueryResponse(BaseModel):
answer: str
sources: List[dict]
model: str
@app.post("/query", response_model=QueryResponse)
async def query_documents(request: QueryRequest):
"""Query your private documents using RAG."""
try:
result = qa_chain.invoke({"query": request.question})
sources = [
{
"content": doc.page_content[:200] + "...",
"source": doc.metadata.get("source", "unknown"),
"page": doc.metadata.get("page", None),
}
for doc in result.get("source_documents", [])
]
return QueryResponse(
answer=result["result"],
sources=sources,
model=request.model,
)
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
@app.post("/upload")
async def upload_document(file: UploadFile = File(...)):
"""Upload a document for ingestion into the RAG pipeline."""
allowed_types = [".pdf", ".docx", ".txt", ".md"]
ext = os.path.splitext(file.filename)[1].lower()
if ext not in allowed_types:
raise HTTPException(
status_code=400,
detail=f"Unsupported file type. Allowed: {allowed_types}",
)
file_path = os.path.join(DOCUMENTS_DIR, file.filename)
with open(file_path, "wb") as buffer:
shutil.copyfileobj(file.file, buffer)
return {"message": f"Uploaded {file.filename}", "path": file_path}
@app.get("/health")
async def health_check():
"""Health check endpoint."""
return {"status": "healthy", "model": LLM_MODEL, "vectorstore": "chromadb"}
# Run: uvicorn api:app --host 127.0.0.1 --port 8000 --workers 2
Ejecutar el Pipeline RAG
# Step 1: Add your documents
cp /path/to/your/documents/*.pdf ~/ai-server/rag/documents/
cp /path/to/your/documents/*.docx ~/ai-server/rag/documents/
# Step 2: Run ingestion
cd ~/ai-server/rag
python ingest.py
# === Private RAG Document Ingestion ===
# Loading documents from: /Users/admin/ai-server/rag/documents
# Loaded: company-handbook.pdf (45 pages)
# Loaded: api-documentation.md
# Loaded: compliance-policy.docx
# Total documents loaded: 47
# Split 47 documents into 312 chunks
# Stored 312 chunks in ChromaDB
# Step 3: Start the RAG API server
uvicorn api:app --host 127.0.0.1 --port 8000 --workers 2 &
# Step 4: Test with a query
curl -s http://localhost:8000/query \
-H "Content-Type: application/json" \
-d '{"question": "What is our company vacation policy?"}' | jq .
# {
# "answer": "According to the company handbook, employees receive...",
# "sources": [...],
# "model": "mistral:7b"
# }
Paso 4: Desplegar Open WebUI
Open WebUI proporciona una interfaz tipo ChatGPT pulida para interactuar con tus modelos locales. Se conecta directamente a Ollama y soporta conversaciones, generación de imágenes y carga de documentos, todo ejecutándose de forma privada en tu Mac Mini.
Instalar Docker
# Install Docker Desktop for Mac (Apple Silicon native)
brew install --cask docker-desktop
# Start Docker Desktop
open -a Docker
# Verify Docker is running
docker --version
# Docker version 26.1.0, build 9714adc
docker compose version
# Docker Compose version v2.27.0
Docker Compose para Open WebUI
# ~/ai-server/docker-compose.yml
version: '3.8'
services:
open-webui:
image: ghcr.io/open-webui/open-webui:main
container_name: open-webui
restart: unless-stopped
ports:
- "127.0.0.1:3000:8080"
environment:
# Connect to Ollama running on the host
- OLLAMA_BASE_URL=http://host.docker.internal:11434
# Disable telemetry and external connections
- ENABLE_SIGNUP=false
- ENABLE_COMMUNITY_SHARING=false
- WEBUI_AUTH=true
- WEBUI_SECRET_KEY=your-strong-secret-key-change-this
# Data privacy settings
- ENABLE_OPENAI_API=false
- ENABLE_OLLAMA_API=true
- SAFE_MODE=true
volumes:
- open-webui-data:/app/backend/data
extra_hosts:
- "host.docker.internal:host-gateway"
# Optional: ChromaDB as a persistent service
chromadb:
image: chromadb/chroma:latest
container_name: chromadb
restart: unless-stopped
ports:
- "127.0.0.1:8200:8000"
volumes:
- chromadb-data:/chroma/chroma
environment:
- IS_PERSISTENT=TRUE
- ANONYMIZED_TELEMETRY=FALSE
volumes:
open-webui-data:
chromadb-data:
Lanzar y Configurar
# Start the services
cd ~/ai-server
docker compose up -d
# Check that containers are running
docker compose ps
# NAME STATUS PORTS
# open-webui Up 2 minutes 127.0.0.1:3000->8080/tcp
# chromadb Up 2 minutes 127.0.0.1:8200->8000/tcp
# View logs
docker compose logs -f open-webui
# Open WebUI is now accessible at http://localhost:3000
# On first visit, create an admin account (this account is local only)
# Verify Ollama connectivity from Open WebUI
curl -s http://localhost:3000/api/config | jq '.ollama'
# To update Open WebUI later:
docker compose pull && docker compose up -d
Nota de Privacidad: Open WebUI está configurado con ENABLE_OPENAI_API=false y ENABLE_COMMUNITY_SHARING=false para asegurar que no se envíen datos a servicios externos. La configuración ENABLE_SIGNUP=false impide que usuarios no autorizados creen cuentas. Todas las conversaciones se almacenan localmente en el volumen Docker.
Paso 5: API Gateway con nginx
nginx sirve como punto de entrada único para todos los servicios. Maneja la terminación SSL/TLS, limitación de velocidad, autenticación y enruta el tráfico a Ollama, Open WebUI y la API RAG.
Instalar y Configurar nginx
# Install nginx
brew install nginx
# Generate a self-signed SSL certificate (or use Let's Encrypt)
mkdir -p ~/ai-server/config/ssl
openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
-keyout ~/ai-server/config/ssl/server.key \
-out ~/ai-server/config/ssl/server.crt \
-subj "/CN=ai-server.local/O=Private AI/C=US"
Configuración de nginx
# /opt/homebrew/etc/nginx/nginx.conf
worker_processes auto;
error_log /Users/admin/ai-server/logs/nginx-error.log;
events {
worker_connections 1024;
}
http {
include mime.types;
default_type application/octet-stream;
# Logging
access_log /Users/admin/ai-server/logs/nginx-access.log;
# Rate limiting zones
limit_req_zone $binary_remote_addr zone=api:10m rate=30r/m;
limit_req_zone $binary_remote_addr zone=chat:10m rate=60r/m;
limit_req_zone $binary_remote_addr zone=upload:10m rate=5r/m;
# Connection limits
limit_conn_zone $binary_remote_addr zone=addr:10m;
# SSL settings
ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers HIGH:!aNULL:!MD5;
ssl_prefer_server_ciphers on;
ssl_session_cache shared:SSL:10m;
ssl_session_timeout 10m;
# Security headers
add_header X-Frame-Options DENY always;
add_header X-Content-Type-Options nosniff always;
add_header X-XSS-Protection "1; mode=block" always;
add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
add_header Content-Security-Policy "default-src 'self'" always;
# Redirect HTTP to HTTPS
server {
listen 80;
server_name ai-server.local;
return 301 https://$host$request_uri;
}
# Main HTTPS server
server {
listen 443 ssl;
server_name ai-server.local;
ssl_certificate /Users/admin/ai-server/config/ssl/server.crt;
ssl_certificate_key /Users/admin/ai-server/config/ssl/server.key;
# Client body size limit (for document uploads)
client_max_body_size 50M;
# Open WebUI (chat interface)
location / {
limit_req zone=chat burst=20 nodelay;
limit_conn addr 10;
proxy_pass http://127.0.0.1:3000;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
# WebSocket support for streaming
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
proxy_read_timeout 300s;
}
# Ollama API (for programmatic access)
location /ollama/ {
limit_req zone=api burst=10 nodelay;
limit_conn addr 5;
# Basic auth for API access
auth_basic "Private AI API";
auth_basic_user_file /Users/admin/ai-server/config/.htpasswd;
rewrite ^/ollama/(.*) /$1 break;
proxy_pass http://127.0.0.1:11434;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_read_timeout 300s;
}
# RAG API
location /rag/ {
limit_req zone=api burst=10 nodelay;
limit_conn addr 5;
auth_basic "Private AI API";
auth_basic_user_file /Users/admin/ai-server/config/.htpasswd;
rewrite ^/rag/(.*) /$1 break;
proxy_pass http://127.0.0.1:8000;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_read_timeout 120s;
}
# Document upload endpoint
location /rag/upload {
limit_req zone=upload burst=3 nodelay;
auth_basic "Private AI API";
auth_basic_user_file /Users/admin/ai-server/config/.htpasswd;
rewrite ^/rag/(.*) /$1 break;
proxy_pass http://127.0.0.1:8000;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
}
# Health check (no auth required)
location /health {
proxy_pass http://127.0.0.1:8000/health;
}
# Deny access to hidden files
location ~ /\. {
deny all;
}
}
}
Configurar Autenticación e Iniciar
# Install htpasswd utility
brew install httpd
# Create API credentials
htpasswd -c ~/ai-server/config/.htpasswd api-user
# Enter a strong password when prompted
# Test nginx configuration
nginx -t
# nginx: configuration file /opt/homebrew/etc/nginx/nginx.conf test is successful
# Start nginx
brew services start nginx
# Test HTTPS access
curl -k https://localhost/health
# {"status": "healthy", "model": "mistral:7b", "vectorstore": "chromadb"}
# Test API access with authentication
curl -k -u api-user:your-password \
https://localhost/ollama/api/tags | jq '.models[].name'
# Test RAG query through nginx
curl -k -u api-user:your-password \
https://localhost/rag/query \
-H "Content-Type: application/json" \
-d '{"question": "What is our data retention policy?"}'
Refuerzo de Seguridad
Un servidor AI privado es tan seguro como su punto de entrada más débil. Esta sección cubre configuración de firewall, refuerzo de SSH, acceso VPN y detección de intrusiones para crear una postura de seguridad de defensa en profundidad.
Firewall de macOS con pf
# ~/ai-server/config/pf.rules
#
# Packet Filter rules for private AI server
# Only allow SSH, HTTPS, and WireGuard VPN from outside
# Define macros
ext_if = "en0"
vpn_if = "utun1"
# Default: block everything
block all
# Allow loopback traffic
pass quick on lo0 all
# Allow established connections
pass in quick on $ext_if proto tcp from any to any flags A/A
# Allow SSH (port 22) - restrict to known IPs if possible
pass in on $ext_if proto tcp from any to any port 22
# Allow HTTPS (port 443) through nginx
pass in on $ext_if proto tcp from any to any port 443
# Allow HTTP (port 80) for redirect to HTTPS
pass in on $ext_if proto tcp from any to any port 80
# Allow WireGuard VPN (port 51820)
pass in on $ext_if proto udp from any to any port 51820
# Allow all traffic on VPN interface
pass on $vpn_if all
# Allow all outbound traffic
pass out on $ext_if all
# Block everything else inbound (implicit from "block all")
# Internal services (11434, 3000, 8000, 8200) are NOT exposed
# --- Load these rules ---
# sudo pfctl -f ~/ai-server/config/pf.rules
# sudo pfctl -e # Enable pf
# sudo pfctl -sr # Show active rules
Autenticación SSH Solo por Clave
# Harden SSH configuration
# Edit /etc/ssh/sshd_config (requires sudo)
# Disable password authentication (key-only)
PasswordAuthentication no
ChallengeResponseAuthentication no
UsePAM no
# Disable root login
PermitRootLogin no
# Only allow specific users
AllowUsers admin
# Use strong key exchange algorithms
KexAlgorithms curve25519-sha256,curve25519-sha256@libssh.org
HostKeyAlgorithms ssh-ed25519,rsa-sha2-512,rsa-sha2-256
Ciphers chacha20-poly1305@openssh.com,aes256-gcm@openssh.com
# Reduce login grace time and max attempts
LoginGraceTime 30
MaxAuthTries 3
MaxSessions 5
# Disable unused features
X11Forwarding no
AllowTcpForwarding no
AllowAgentForwarding no
# Restart SSH
# sudo launchctl stop com.openssh.sshd
# sudo launchctl start com.openssh.sshd
WireGuard VPN para Acceso Remoto Seguro
# Install WireGuard
brew install wireguard-tools
# Generate server keys
wg genkey | tee ~/ai-server/config/wg-server-private.key | \
wg pubkey > ~/ai-server/config/wg-server-public.key
# Generate client keys
wg genkey | tee ~/ai-server/config/wg-client-private.key | \
wg pubkey > ~/ai-server/config/wg-client-public.key
# Server configuration
cat <<EOF > ~/ai-server/config/wg0.conf
[Interface]
PrivateKey = $(cat ~/ai-server/config/wg-server-private.key)
Address = 10.66.66.1/24
ListenPort = 51820
PostUp = echo "WireGuard started"
PostDown = echo "WireGuard stopped"
[Peer]
# Client 1 - Your workstation
PublicKey = $(cat ~/ai-server/config/wg-client-public.key)
AllowedIPs = 10.66.66.2/32
PersistentKeepalive = 25
EOF
# Client configuration (copy to your workstation)
cat <<EOF > ~/ai-server/config/wg-client.conf
[Interface]
PrivateKey = $(cat ~/ai-server/config/wg-client-private.key)
Address = 10.66.66.2/24
DNS = 1.1.1.1
[Peer]
PublicKey = $(cat ~/ai-server/config/wg-server-public.key)
Endpoint = your-mac-mini.myremotemac.com:51820
AllowedIPs = 10.66.66.0/24
PersistentKeepalive = 25
EOF
# Start WireGuard on the server
sudo wg-quick up ~/ai-server/config/wg0.conf
# Verify connection
sudo wg show
# interface: utun1
# public key: <server-public-key>
# listening port: 51820
#
# peer: <client-public-key>
# allowed ips: 10.66.66.2/32
Monitorización de Intentos de Inicio de Sesión (equivalente a fail2ban)
# ~/ai-server/scripts/monitor-ssh.sh
#!/bin/bash
# Simple SSH brute-force detection and blocking for macOS
# Run via cron every 5 minutes
LOG_FILE="/var/log/system.log"
BLOCK_THRESHOLD=5
BLOCK_FILE="$HOME/ai-server/config/blocked_ips.txt"
# Find IPs with failed SSH attempts in the last 10 minutes
failed_ips=$(log show --predicate 'process == "sshd" AND eventMessage CONTAINS "Failed"' \
--last 10m 2>/dev/null | \
grep -oE '([0-9]{1,3}\.){3}[0-9]{1,3}' | \
sort | uniq -c | sort -rn)
echo "$failed_ips" | while read count ip; do
if [ "$count" -ge "$BLOCK_THRESHOLD" ] && [ -n "$ip" ]; then
# Check if already blocked
if ! grep -q "$ip" "$BLOCK_FILE" 2>/dev/null; then
echo "$(date): Blocking $ip ($count failed attempts)" >> ~/ai-server/logs/security.log
echo "$ip" >> "$BLOCK_FILE"
# Add pf block rule
echo "block in quick from $ip to any" | sudo pfctl -f - -a "blocked/$ip" 2>/dev/null
fi
fi
done
# Make executable and add to crontab:
# chmod +x ~/ai-server/scripts/monitor-ssh.sh
# crontab -e
# */5 * * * * ~/ai-server/scripts/monitor-ssh.sh
Lista de Verificación de Seguridad:
- Autenticación SSH solo por clave habilitada, contraseñas desactivadas
- Todos los servicios AI vinculados solo a localhost (127.0.0.1)
- nginx es el único servicio expuesto al público (puertos 80/443)
- El firewall pf bloquea todo el tráfico entrante no esencial
- WireGuard VPN para administración remota segura
- Limitación de velocidad en todos los endpoints API
- Autenticación básica en los endpoints de Ollama y API RAG
- Detección automatizada de fuerza bruta y bloqueo de IP
- Cabeceras de seguridad (HSTS, CSP, X-Frame-Options) en todas las respuestas
Análisis de Costes
Las APIs de AI en la nube cobran por token, así que la factura crece con cada solicitud. Un Mac Mini M4 proporciona inferencia ilimitada a una tarifa mensual fija. Cuál de los dos cuesta menos depende de tu volumen: con poco volumen, la API es más barata. En las tablas de abajo, el servidor privado alcanza el punto de equilibrio en torno a 120.000 solicitudes al mes frente a GPT-3.5-Turbo, y con ese volumen ya ahorra dinero frente a GPT-4-Turbo.
API de OpenAI vs. Mac Mini M4 Privado
La comparación asume los precios de lista de GPT-3.5-Turbo a octubre de 2026 ($0,50/1M tokens de entrada, $1,50/1M tokens de salida) vs. un Mac mini M4 dedicado ejecutando Llama 3 8B. Solicitud promedio: 500 tokens de entrada + 300 tokens de salida.
| Solicitudes Mensuales | Coste Mac Mini M4 | Coste API OpenAI | Ahorro |
|---|---|---|---|
| 1,000 | $85 | $0.70 | −$84.30 (API más barata) |
| 10,000 | $85 | $7.00 | −$78.00 (API más barata) |
| 100,000 | $85 | $70.00 | −$15.00 (API más barata) |
| 500,000 | $85 | $350.00 | $265 (76% de ahorro) |
| 1,000,000 | $85 | $700.00 | $615 (88% de ahorro) |
USD al mes, sin impuestos.
Comparación Nivel GPT-4
Para calidad de nivel GPT-4, compara GPT-4-Turbo (precio de lista a octubre de 2026: $10/1M entrada, $30/1M salida) vs. Mac mini M4 Pro 48GB ejecutando Llama 3 70B.
| Solicitudes Mensuales | Coste Mac Mini M4 Pro | Coste GPT-4 Turbo | Ahorro |
|---|---|---|---|
| 10,000 | $299 | $140.00 | −$159.00 (API más barata) |
| 100,000 | $299 | $1,400.00 | $1,101 (79% de ahorro) |
| 1,000,000 | $299 | $14,000.00 | $13,701 (98% de ahorro) |
USD al mes, sin impuestos.
Más Allá del Coste: Por debajo del punto de equilibrio, la API cuesta menos, y un servidor AI privado se elige por control, no por ahorro. Tus prompts y documentos se quedan en un Mac físico asignado 1:1 a ti, con acceso root completo, en lugar de pasar por una API de AI de terceros. Pagas una tarifa mensual fija, sin facturación por token ni compromiso, así que puedes iterar sin preocuparte por la facturación de APIs. Tus costes se mantienen fijos ya sea que ejecutes 100 solicitudes o 10 millones.
Escalado
Un solo Mac Mini M4 puede manejar 2-4 solicitudes concurrentes para un modelo de 7B. Cuando necesitas más rendimiento o quieres especialización de modelos, escalar horizontalmente con múltiples Mac Minis es sencillo.
Arquitectura Multi-Nodo
Nodo 1: Chat General
Mac Mini M4 16GB
Llama 3 8B para conversaciones de propósito general, soporte al cliente y generación de contenido.
$85/mesUSD, sin impuestos
Nodo 2: Asistente de Código
Mac Mini M4 24GB
CodeLlama 13B para generación de código, revisión y tareas de refactorización.
$129/mesUSD, sin impuestos
Nodo 3: RAG y Razonamiento
Mac Mini M4 Pro 48GB
Llama 3 70B para análisis complejo de documentos, investigación legal y tareas de razonamiento profundo.
$299/mesUSD, sin impuestos
Balanceo de Carga con nginx
# nginx upstream configuration for multi-node load balancing
# Define upstream groups by model type
upstream ollama_general {
# Round-robin across general chat nodes
server 10.66.66.10:11434; # Node 1
server 10.66.66.11:11434; # Node 1 replica (if needed)
keepalive 8;
}
upstream ollama_code {
server 10.66.66.20:11434; # Node 2 - Code models
keepalive 4;
}
upstream ollama_reasoning {
server 10.66.66.30:11434; # Node 3 - Large models
keepalive 4;
}
# Model routing based on request path
server {
listen 443 ssl;
server_name ai-cluster.local;
# Route general chat requests
location /v1/chat/ {
proxy_pass http://ollama_general;
proxy_read_timeout 300s;
}
# Route code generation requests
location /v1/code/ {
proxy_pass http://ollama_code;
proxy_read_timeout 300s;
}
# Route reasoning/analysis requests
location /v1/reasoning/ {
proxy_pass http://ollama_reasoning;
proxy_read_timeout 600s;
}
}
Script de Enrutamiento de Modelos
# ~/ai-server/scripts/model_router.py
"""
Intelligent model router that directs requests to the appropriate
Mac Mini node based on the requested model and current load.
"""
from fastapi import FastAPI, Request
import httpx
import asyncio
app = FastAPI()
NODES = {
"general": {
"url": "http://10.66.66.10:11434",
"models": ["llama3:8b", "mistral:7b"],
},
"code": {
"url": "http://10.66.66.20:11434",
"models": ["codellama:7b", "codellama:13b"],
},
"reasoning": {
"url": "http://10.66.66.30:11434",
"models": ["llama3:70b", "mixtral:8x7b"],
},
}
def get_node_for_model(model: str) -> str:
"""Find which node hosts the requested model."""
for node_name, config in NODES.items():
if model in config["models"]:
return config["url"]
# Default to general node
return NODES["general"]["url"]
@app.post("/v1/chat/completions")
async def route_chat(request: Request):
body = await request.json()
model = body.get("model", "llama3:8b")
target_url = get_node_for_model(model)
async with httpx.AsyncClient(timeout=300) as client:
response = await client.post(
f"{target_url}/v1/chat/completions",
json=body,
)
return response.json()
@app.get("/v1/models")
async def list_all_models():
"""Aggregate model lists from all nodes."""
all_models = []
async with httpx.AsyncClient(timeout=10) as client:
for node_name, config in NODES.items():
try:
resp = await client.get(f"{config['url']}/api/tags")
models = resp.json().get("models", [])
for m in models:
m["node"] = node_name
all_models.extend(models)
except Exception:
pass
return {"models": all_models}
# Run: uvicorn model_router:app --host 0.0.0.0 --port 8080
Preguntas Frecuentes
¿Un servidor AI autoalojado es verdaderamente privado si alquilo el hardware?
¿Puedo cumplir con GDPR y HIPAA con esta configuración?
¿Cómo se compara la calidad de los modelos locales con GPT-4 o Claude?
¿Qué pasa si el servidor se cae?
KeepAlive (Ollama vía launchd) y restart: unless-stopped (contenedores Docker), así que se reinician tras un fallo. Se ejecutan en tu sesión de usuario (un LaunchAgent y Docker Desktop): en un Mac mini headless, activa el inicio de sesión automático para ese usuario (Ajustes del Sistema > Usuarios y grupos; no disponible con FileVault activado) y deja que Docker Desktop arranque al iniciar sesión, para que todos los servicios vuelvan también tras un reinicio. Para cargas de trabajo de producción, considera ejecutar dos Mac mini con balanceo de carga nginx para alta disponibilidad. La infraestructura de My Remote Mac incluye monitorización 24/7 y conectividad de red y energía redundante.¿Puedo usar esta configuración con herramientas existentes como Cursor, Continue.dev o VS Code?
https://tu-servidor/ollama/v1 con tus credenciales de autenticación básica. Las extensiones de VS Code como Continue, Cody y Tabby soportan endpoints personalizados. Tu código nunca sale de tu servidor.¿Cómo actualizo los modelos cuando se lanzan nuevas versiones?
ollama pull llama3:8b descargará la última versión. La versión anterior se mantiene hasta que la elimines explícitamente con ollama rm. Puedes probar nuevas versiones de modelos junto a las existentes y cambiar en producción con cero tiempo de inactividad actualizando el nombre del modelo en tus llamadas API o la configuración de nginx.