Upload folder using huggingface_hub

.env.example

@@ -0,0 +1,25 @@
+# Variables de entorno para GPT Local
+# Copia este archivo a .env y completa los valores
+
+# Hugging Face Token (opcional pero recomendado)
+# Obtén tu token en: https://huggingface.co/settings/tokens
+HUGGINGFACE_TOKEN=hf_your_token_here
+
+# GitHub Token (opcional, para repositorios privados)
+# Obtén tu token en: https://github.com/settings/tokens
+GITHUB_TOKEN=ghp_your_token_here
+
+# Configuración del modelo por defecto
+DEFAULT_MODEL=microsoft/DialoGPT-small
+
+# Configuración de Gradio
+GRADIO_SERVER_NAME=0.0.0.0
+GRADIO_SERVER_PORT=7860
+GRADIO_SHARE=false
+
+# Docker configuración
+DOCKER_IMAGE_NAME=gpt-local
+DOCKER_CONTAINER_NAME=gpt-local-app
+
+# Configuración de dispositivo (auto, cpu, mps, cuda)
+DEVICE=auto

.github/copilot-instructions.md

@@ -0,0 +1,26 @@
+<!-- Use this file to provide workspace-specific custom instructions to Copilot. For more details, visit https://code.visualstudio.com/docs/copilot/copilot-customization#_use-a-githubcopilotinstructionsmd-file -->
+- [x] Verify that the copilot-instructions.md file in the .github directory is created.
+
+- [x] Clarify Project Requirements
+	<!-- Proyecto: GPT de texto local usando Hugging Face con Python, interfaz de chat, carga de modelos preentrenados -->
+
+- [x] Scaffold the Project
+	<!-- Estructura creada: main.py, models/, ui/, config/, requirements.txt -->
+
+- [x] Customize the Project
+	<!-- Proyecto personalizado con interfaz Gradio, cargador de modelos HuggingFace, generador de texto -->
+
+- [x] Install Required Extensions
+	<!-- No se requieren extensiones específicas para este proyecto Python -->
+
+- [x] Compile the Project
+	<!-- Dependencias instaladas exitosamente: PyTorch 2.7.1, Transformers 4.53.0, Gradio 4.44.1 -->
+
+- [x] Create and Run Task
+	<!-- Tarea creada para ejecutar el GPT Local, versión de terminal funcional -->
+
+- [x] Launch the Project
+	<!-- Proyecto listo para ejecutar: chat_terminal.py y main.py disponibles -->
+
+- [x] Ensure Documentation is Complete
+	<!-- README.md y copilot-instructions.md completados con información del proyecto -->

.gitignore

@@ -0,0 +1,141 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+Pipfile.lock
+
+# PEP 582
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# Hugging Face cache
+models_cache/
+.cache/
+
+# macOS
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# VS Code
+.vscode/settings.json
+.vscode/launch.json
+
+# GPT Local specific
+*.log
+temp/
+downloads/

.pylintrc

@@ -0,0 +1,35 @@
+[MASTER]
+# Ignorar errores en archivos de configuración
+ignore=.gitignore,setup.sh
+
+[MESSAGES CONTROL]
+# Deshabilitar algunos warnings que no son críticos
+disable=
+    missing-module-docstring,
+    missing-function-docstring,
+    missing-class-docstring,
+    too-few-public-methods,
+    import-error,
+    no-member,
+    unused-import,
+    unused-variable,
+    broad-except,
+    line-too-long,
+    invalid-name,
+    consider-using-f-string
+
+[FORMAT]
+# Longitud máxima de línea
+max-line-length=120
+
+[BASIC]
+# Convenciones de nombres
+good-names=i,j,k,ex,Run,_,gr,os
+
+[DESIGN]
+# Límites de complejidad
+max-args=7
+max-locals=15
+max-returns=6
+max-branches=12
+max-statements=50

.vscode/tasks.json

@@ -0,0 +1,13 @@
+{
+	"version": "2.0.0",
+	"tasks": [
+		{
+			"label": "Ejecutar GPT Local",
+			"type": "shell",
+			"command": "python3 main.py",
+			"isBackground": true,
+			"problemMatcher": [],
+			"group": "build"
+		}
+	]
+}

Dockerfile

@@ -0,0 +1,62 @@
+# 🤖 GPT Local - Optimized Docker Container  
+FROM python:3.12-alpine
+
+# Instalar dependencias del sistema necesarias
+RUN apk add --no-cache \
+    gcc \
+    musl-dev \
+    libffi-dev \
+    openssl-dev \
+    curl \
+    ca-certificates \
+    git \
+    && apk upgrade --no-cache
+
+# Metadata
+LABEL maintainer="GPT Local Team"
+LABEL description="Sistema de chat GPT local con Hugging Face"
+LABEL version="1.0"
+
+# Configurar variables de entorno
+ENV PYTHONPATH=/app
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+ENV HF_HOME=/app/.cache/huggingface
+ENV TRANSFORMERS_CACHE=/app/.cache/huggingface
+ENV TORCH_HOME=/app/.cache/torch
+
+# Crear directorio de trabajo
+WORKDIR /app
+
+# Crear usuario no privilegiado
+RUN addgroup -g 1000 appuser && \
+    adduser -D -s /bin/sh -u 1000 -G appuser appuser
+
+# Copiar y instalar dependencias
+COPY requirements.txt .
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Copiar código de la aplicación
+COPY . .
+
+# Crear directorios necesarios con permisos apropiados
+RUN mkdir -p models models_cache logs .cache/huggingface .cache/torch && \
+    chown -R appuser:appuser /app
+
+# Cambiar a usuario no privilegiado
+USER appuser
+
+# Configurar permisos
+RUN chmod +x *.py 2>/dev/null || true && \
+    chmod +x *.sh 2>/dev/null || true
+
+# Exponer puerto
+EXPOSE 7860
+
+# Healthcheck mejorado
+HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
+    CMD curl -f http://localhost:7860/health || curl -f http://localhost:7860/ || exit 1
+
+# Comando por defecto
+CMD ["python3", "main.py"]

Dockerfile.backup

@@ -0,0 +1,53 @@
+# 🤖 GPT Local - Optimized Docker Container
+FROM python:3.11-slim
+
+# Metadata
+LABEL maintainer="GPT Local Team"
+LABEL description="Sistema de chat GPT local con Hugging Face"
+LABEL version="1.0"
+
+# Configurar variables de entorno
+ENV PYTHONPATH=/app
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+ENV HF_HOME=/app/.cache/huggingface
+ENV TRANSFORMERS_CACHE=/app/.cache/huggingface
+ENV TORCH_HOME=/app/.cache/torch
+
+# Instalar dependencias del sistema
+RUN apt-get update && apt-get install -y \
+    curl \
+    git \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/* \
+    && apt-get clean
+
+# Crear directorio de trabajo
+WORKDIR /app
+
+# Copiar archivos de requirements primero (para cache de Docker)
+COPY requirements.txt requirements-dev.txt ./
+
+# Instalar dependencias Python
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Copiar código fuente
+COPY . .
+
+# Crear directorios necesarios
+RUN mkdir -p models models_cache logs .cache/huggingface .cache/torch
+
+# Configurar permisos
+RUN chmod +x *.py && \
+    chmod +x *.sh 2>/dev/null || true
+
+# Exponer puerto
+EXPOSE 7860
+
+# Healthcheck
+HEALTHCHECK --interval=30s --timeout=10s --start-period=40s --retries=3 \
+    CMD curl -f http://localhost:7860/ || exit 1
+
+# Comando por defecto (interfaz web)
+CMD ["python3", "main.py"]

INSTRUCCIONES.md

@@ -0,0 +1,93 @@
+# 🚀 Instrucciones de Uso - GPT Local
+
+## ✅ Estado del Proyecto
+
+Tu GPT local con Hugging Face está **completamente configurado y funcionando**. Las dependencias se han instalado correctamente:
+
+- ✅ PyTorch 2.7.1
+- ✅ Transformers 4.53.0
+- ✅ Gradio 4.44.1
+- ✅ Modelos preentrenados disponibles
+
+## 🎯 Opciones de Ejecución
+
+### 1. Chat en Terminal (Recomendado)
+
+```bash
+cd /Users/kuchimac/gpt-local
+python3 chat_terminal.py
+```
+
+**Ventajas:**
+
+- Funciona inmediatamente
+- Sin problemas de puerto o navegador
+- Ideal para pruebas rápidas
+
+### 2. Interfaz Web con Gradio
+
+```bash
+cd /Users/kuchimac/gpt-local
+python3 main.py
+```
+
+**Nota:** Si tienes problemas con Gradio, usa la versión de terminal.
+
+### 3. Prueba Rápida
+
+```bash
+cd /Users/kuchimac/gpt-local
+python3 test_gpt.py
+```
+
+## 🤖 Modelos Disponibles
+
+- `microsoft/DialoGPT-small` (por defecto, ~117MB)
+- `gpt2` (~548MB)
+- `distilgpt2` (~319MB)
+
+## 💬 Comandos del Chat
+
+En el chat de terminal:
+
+- Escribe tu mensaje y presiona Enter
+- `reset` - Reinicia la conversación
+- `salir` - Cierra la aplicación
+
+## ⚙️ Configuración
+
+Edita `config/settings.py` para:
+
+- Cambiar el modelo por defecto
+- Ajustar parámetros de generación
+- Modificar configuración de red
+
+## 🔧 Resolución de Problemas
+
+**Si el modelo no carga:**
+
+```bash
+# Verificar que las dependencias estén instaladas
+python3 -c "import torch, transformers; print('OK')"
+```
+
+**Si hay errores de memoria:**
+
+- Usa `microsoft/DialoGPT-small` en lugar de modelos más grandes
+- Cierra otras aplicaciones para liberar RAM
+
+**Si hay problemas con PYTHONPATH:**
+
+```bash
+export PYTHONPATH="/Users/kuchimac/Library/Python/3.9/lib/python/site-packages:/Users/kuchimac/gpt-local"
+```
+
+## 🎉 ¡Ya está listo
+
+Tu GPT local está funcionando. Puedes empezar a chatear inmediatamente usando:
+
+```bash
+python3 chat_terminal.py
+```
+
+¡Disfruta tu GPT completamente privado y local! 🔒

README.md

@@ -0,0 +1,100 @@
+# 🤖 GPT Local - Sistema de Chat con Hugging Face
+
+[![Docker](https://img.shields.io/badge/docker-%230db7ed.svg?style=for-the-badge&logo=docker&logoColor=white)](https://docker.com/)
+[![Python](https://img.shields.io/badge/python-3.9+-blue.svg?style=for-the-badge&logo=python&logoColor=white)](https://python.org/)
+[![Hugging Face](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Transformers-yellow?style=for-the-badge)](https://huggingface.co/)
+[![PyTorch](https://img.shields.io/badge/PyTorch-%23EE4C2C.svg?style=for-the-badge&logo=PyTorch&logoColor=white)](https://pytorch.org/)
+
+Un sistema completo de chat GPT local usando modelos de Hugging Face con soporte para Docker, interfaz web y terminal.
+
+## 🚀 Características
+
+- 💬 **Chat Terminal**: Interfaz de línea de comandos rápida y eficiente
+- 🌐 **Interfaz Web**: Gradio UI moderna y responsiva
+- 🐳 **Docker Ready**: Despliegue containerizado completo
+- 🤗 **Hugging Face**: Soporte para múltiples modelos preentrenados
+- 🍎 **Apple Silicon**: Optimización MPS para M1/M2/M3 Macs
+- ⚡ **GPU Acceleration**: CUDA y MPS automático
+- 📦 **Easy Setup**: Configuración automática de dependencias
+
+- 🤖 Interfaz de chat interactiva
+- 🔒 Completamente local y privado
+- 🚀 Modelos preentrenados de Hugging Face
+- 💬 Generación de texto conversacional
+- ⚙️ Configuración personalizable
+
+## Requisitos
+
+- Python 3.8 o superior
+- torch
+- transformers
+- gradio (para la interfaz web)
+
+## Instalación
+
+1. Instalar dependencias:
+
+```bash
+pip install -r requirements.txt
+```
+
+1. Ejecutar la aplicación:
+
+**Chat en Terminal:**
+
+```bash
+python3 chat_terminal.py
+```
+
+**Interfaz Web (si Gradio funciona):**
+
+```bash
+python3 main.py
+```
+
+**Prueba rápida:**
+
+```bash
+python3 test_gpt.py
+```
+
+## Uso
+
+La aplicación abrirá una interfaz web en `http://localhost:7860` donde podrás:
+
+- Chatear con el modelo GPT local
+- Ajustar parámetros de generación
+- Cambiar entre diferentes modelos
+
+## Modelos Disponibles
+
+- GPT-2 (por defecto)
+- DialoGPT
+- Otros modelos compatibles de Hugging Face
+
+## Estructura del Proyecto
+
+```text
+gpt-local/
+├── main.py              # Aplicación principal
+├── models/              # Gestión de modelos
+│   ├── __init__.py
+│   ├── model_loader.py  # Carga de modelos
+│   └── text_generator.py # Generación de texto
+├── ui/                  # Interfaz de usuario
+│   ├── __init__.py
+│   └── gradio_interface.py
+├── config/              # Configuración
+│   ├── __init__.py
+│   └── settings.py
+├── requirements.txt     # Dependencias
+└── README.md           # Esta documentación
+```
+
+## Configuración
+
+Edita `config/settings.py` para personalizar:
+
+- Modelo por defecto
+- Parámetros de generación
+- Puerto de la interfaz web

chat_terminal.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+"""
+Versión simple del GPT Local sin Gradio
+"""
+
+import sys
+import logging
+from pathlib import Path
+
+# Agregar el directorio raíz al path
+sys.path.append(str(Path(__file__).parent))
+
+from models.model_loader import ModelLoader
+from models.text_generator import TextGenerator
+from config.settings import DEFAULT_MODEL
+
+def setup_logging():
+    """Configurar el sistema de logging"""
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    )
+
+def main():
+    """Función principal para el chat en terminal"""
+    setup_logging()
+    logger = logging.getLogger(__name__)
+    
+    print("🤖 GPT Local - Chat en Terminal")
+    print("="*50)
+    
+    # Inicializar componentes
+    model_loader = ModelLoader()
+    text_generator = TextGenerator(model_loader)
+    
+    # Cargar modelo por defecto
+    print(f"📦 Cargando modelo: {DEFAULT_MODEL}")
+    if not model_loader.load_model(DEFAULT_MODEL):
+        print("❌ Error al cargar el modelo")
+        return
+    
+    print("✅ Modelo cargado exitosamente")
+    print("💡 Escribe 'salir' para terminar")
+    print("💡 Escribe 'reset' para reiniciar el chat")
+    print("-"*50)
+    
+    try:
+        while True:
+            # Obtener entrada del usuario
+            user_input = input("\n👤 Tú: ").strip()
+            
+            if user_input.lower() in ['salir', 'exit', 'quit']:
+                print("👋 ¡Hasta luego!")
+                break
+            
+            if user_input.lower() == 'reset':
+                text_generator.reset_chat_history()
+                print("🔄 Chat reiniciado")
+                continue
+            
+            if not user_input:
+                continue
+            
+            # Generar respuesta
+            print("🤖 GPT: ", end="", flush=True)
+            try:
+                response = text_generator.generate_response(
+                    user_input,
+                    temperature=0.7,
+                    max_length=200
+                )
+                print(response)
+                
+            except Exception as e:
+                print(f"❌ Error: {str(e)}")
+                
+    except KeyboardInterrupt:
+        print("\n👋 Chat interrumpido por el usuario")
+    except Exception as e:
+        logger.error(f"❌ Error en el chat: {str(e)}")
+
+if __name__ == "__main__":
+    main()

config/__init__.py

@@ -0,0 +1 @@
+# Módulo de configuración

config/settings.py

@@ -0,0 +1,41 @@
+"""
+Configuración del GPT Local
+"""
+
+# Configuración de modelos
+DEFAULT_MODEL = "microsoft/DialoGPT-small"
+
+AVAILABLE_MODELS = [
+    "microsoft/DialoGPT-small",
+    "gpt2",
+    "distilgpt2"
+]
+
+# Parámetros de generación por defecto
+DEFAULT_GENERATION_PARAMS = {
+    "temperature": 0.7,
+    "max_length": 512,
+    "top_p": 0.9,
+    "do_sample": True
+}
+
+# Configuración de la interfaz web
+WEB_CONFIG = {
+    "host": "127.0.0.1",
+    "port": 7860,
+    "share": False,
+    "debug": False
+}
+
+# Configuración de logging
+LOGGING_CONFIG = {
+    "level": "INFO",
+    "format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+}
+
+# Configuración del dispositivo
+DEVICE_CONFIG = {
+    "auto_select": True,  # Seleccionar automáticamente GPU si está disponible
+    "force_cpu": False,   # Forzar uso de CPU
+    "torch_dtype": "auto" # "float16" para GPU, "float32" para CPU
+}

docker-compose.yml

@@ -0,0 +1,41 @@
+version: '3.8'
+
+services:
+  gpt-local:
+    build: .
+    container_name: gpt-local
+    ports:
+      - "7860:7860"
+    volumes:
+      # Persistir cache de modelos
+      - ./models_cache:/app/models_cache
+      - ~/.cache/huggingface:/root/.cache/huggingface
+    environment:
+      - PYTHONPATH=/app
+      - HF_HOME=/root/.cache/huggingface
+      - HUGGINGFACE_TOKEN=${HUGGINGFACE_TOKEN}
+      - GITHUB_TOKEN=${GITHUB_TOKEN}
+      - DEFAULT_MODEL=${DEFAULT_MODEL:-microsoft/DialoGPT-small}
+      - DEVICE=${DEVICE:-auto}
+    # Para chat en terminal
+    tty: true
+    stdin_open: true
+    command: python3 chat_terminal.py
+
+  gpt-local-web:
+    build: .
+    container_name: gpt-local-web
+    ports:
+      - "7860:7860"
+    volumes:
+      - ./models_cache:/app/models_cache
+      - ~/.cache/huggingface:/root/.cache/huggingface
+    environment:
+      - PYTHONPATH=/app
+      - HF_HOME=/root/.cache/huggingface
+      - HUGGINGFACE_TOKEN=${HUGGINGFACE_TOKEN}
+      - GITHUB_TOKEN=${GITHUB_TOKEN}
+      - DEFAULT_MODEL=${DEFAULT_MODEL:-microsoft/DialoGPT-small}
+      - DEVICE=${DEVICE:-auto}
+    # Para interfaz web
+    command: python3 main.py

docker-manager.sh

@@ -0,0 +1,314 @@
+#!/bin/bash
+# 🐳 Script de gestión completa de Docker para GPT Local
+# Construye, publica y despliega containers en Docker Hub
+
+set -e
+
+# Cargar variables de entorno
+if [ -f .env ]; then
+    export $(cat .env | grep -v '^#' | xargs)
+fi
+
+# Colores para output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+print_status() {
+    echo -e "${BLUE}[INFO]${NC} $1"
+}
+
+print_success() {
+    echo -e "${GREEN}[SUCCESS]${NC} $1"
+}
+
+print_warning() {
+    echo -e "${YELLOW}[WARNING]${NC} $1"
+}
+
+print_error() {
+    echo -e "${RED}[ERROR]${NC} $1"
+}
+
+# Variables
+DOCKER_USERNAME=${DOCKER_USERNAME:-"drtv"}
+IMAGE_NAME=${DOCKER_IMAGE_NAME:-"gpt-local"}
+VERSION=${1:-"latest"}
+FULL_IMAGE_NAME="$DOCKER_USERNAME/$IMAGE_NAME:$VERSION"
+
+# Función para construir imagen
+build_image() {
+    print_status "Construyendo imagen Docker: $FULL_IMAGE_NAME"
+    
+    # Crear Dockerfile optimizado si no existe una versión reciente
+    create_optimized_dockerfile
+    
+    # Construir imagen
+    if docker build -t "$FULL_IMAGE_NAME" -t "$DOCKER_USERNAME/$IMAGE_NAME:latest" .; then
+        print_success "Imagen construida exitosamente: $FULL_IMAGE_NAME"
+        
+        # Mostrar tamaño de la imagen
+        local size=$(docker images --format "table {{.Repository}}:{{.Tag}}\t{{.Size}}" | grep "$DOCKER_USERNAME/$IMAGE_NAME" | head -1 | awk '{print $2}')
+        print_status "Tamaño de la imagen: $size"
+    else
+        print_error "Error construyendo la imagen"
+        return 1
+    fi
+}
+
+# Función para crear Dockerfile optimizado
+create_optimized_dockerfile() {
+    cat > Dockerfile << 'EOF'
+# 🤖 GPT Local - Optimized Docker Container
+FROM python:3.11-slim
+
+# Metadata
+LABEL maintainer="GPT Local Team"
+LABEL description="Sistema de chat GPT local con Hugging Face"
+LABEL version="1.0"
+
+# Configurar variables de entorno
+ENV PYTHONPATH=/app
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+ENV HF_HOME=/app/.cache/huggingface
+ENV TRANSFORMERS_CACHE=/app/.cache/huggingface
+ENV TORCH_HOME=/app/.cache/torch
+
+# Instalar dependencias del sistema
+RUN apt-get update && apt-get install -y \
+    curl \
+    git \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/* \
+    && apt-get clean
+
+# Crear directorio de trabajo
+WORKDIR /app
+
+# Copiar archivos de requirements primero (para cache de Docker)
+COPY requirements.txt requirements-dev.txt ./
+
+# Instalar dependencias Python
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Copiar código fuente
+COPY . .
+
+# Crear directorios necesarios
+RUN mkdir -p models models_cache logs .cache/huggingface .cache/torch
+
+# Configurar permisos
+RUN chmod +x *.py && \
+    chmod +x *.sh 2>/dev/null || true
+
+# Exponer puerto
+EXPOSE 7860
+
+# Healthcheck
+HEALTHCHECK --interval=30s --timeout=10s --start-period=40s --retries=3 \
+    CMD curl -f http://localhost:7860/ || exit 1
+
+# Comando por defecto (interfaz web)
+CMD ["python3", "main.py"]
+EOF
+    print_success "Dockerfile optimizado creado"
+}
+
+# Función para hacer push a Docker Hub
+push_image() {
+    print_status "Subiendo imagen a Docker Hub: $FULL_IMAGE_NAME"
+    
+    # Verificar login
+    if ! docker info | grep -q "Username: $DOCKER_USERNAME"; then
+        print_error "No estás logueado en Docker Hub como $DOCKER_USERNAME"
+        print_status "Ejecuta: echo 'tu_token' | docker login -u $DOCKER_USERNAME --password-stdin"
+        return 1
+    fi
+    
+    # Push imagen con tag específico
+    if docker push "$FULL_IMAGE_NAME"; then
+        print_success "Imagen $FULL_IMAGE_NAME subida exitosamente"
+    else
+        print_error "Error subiendo imagen con tag $VERSION"
+        return 1
+    fi
+    
+    # Push imagen latest
+    if docker push "$DOCKER_USERNAME/$IMAGE_NAME:latest"; then
+        print_success "Imagen latest subida exitosamente"
+        print_status "Imagen disponible en: https://hub.docker.com/r/$DOCKER_USERNAME/$IMAGE_NAME"
+    else
+        print_error "Error subiendo imagen latest"
+        return 1
+    fi
+}
+
+# Función para correr container localmente
+run_container() {
+    local mode=${1:-"web"}
+    
+    print_status "Ejecutando container en modo: $mode"
+    
+    # Parar container si ya está corriendo
+    docker stop "$DOCKER_USERNAME-$IMAGE_NAME" 2>/dev/null || true
+    docker rm "$DOCKER_USERNAME-$IMAGE_NAME" 2>/dev/null || true
+    
+    case $mode in
+        "web")
+            docker run -d \
+                --name "$DOCKER_USERNAME-$IMAGE_NAME" \
+                -p 7860:7860 \
+                -v "$(pwd)/models_cache:/app/models_cache" \
+                -v "$(pwd)/logs:/app/logs" \
+                -e HUGGINGFACE_TOKEN="$HUGGINGFACE_TOKEN" \
+                -e DEFAULT_MODEL="$DEFAULT_MODEL" \
+                -e DEVICE="$DEVICE" \
+                "$FULL_IMAGE_NAME"
+            
+            print_success "Container web ejecutándose en: http://localhost:7860"
+            ;;
+        "terminal")
+            docker run -it \
+                --name "$DOCKER_USERNAME-$IMAGE_NAME-terminal" \
+                -v "$(pwd)/models_cache:/app/models_cache" \
+                -e HUGGINGFACE_TOKEN="$HUGGINGFACE_TOKEN" \
+                -e DEFAULT_MODEL="$DEFAULT_MODEL" \
+                -e DEVICE="$DEVICE" \
+                "$FULL_IMAGE_NAME" \
+                python3 chat_terminal.py
+            ;;
+        "dev")
+            docker run -it \
+                --name "$DOCKER_USERNAME-$IMAGE_NAME-dev" \
+                -p 7860:7860 \
+                -v "$(pwd):/app" \
+                -e HUGGINGFACE_TOKEN="$HUGGINGFACE_TOKEN" \
+                -e DEFAULT_MODEL="$DEFAULT_MODEL" \
+                -e DEVICE="$DEVICE" \
+                "$FULL_IMAGE_NAME" \
+                bash
+            ;;
+    esac
+}
+
+# Función para correr con docker-compose
+run_compose() {
+    local service=${1:-"gpt-local-web"}
+    
+    print_status "Ejecutando con docker-compose: $service"
+    
+    # Construir y ejecutar
+    if docker-compose up --build -d "$service"; then
+        print_success "Servicio $service ejecutándose"
+        
+        if [ "$service" = "gpt-local-web" ]; then
+            print_status "Interfaz web disponible en: http://localhost:7860"
+        fi
+        
+        # Mostrar logs
+        print_status "Logs del servicio (Ctrl+C para salir):"
+        docker-compose logs -f "$service"
+    else
+        print_error "Error ejecutando docker-compose"
+        return 1
+    fi
+}
+
+# Función para limpiar imágenes y containers
+cleanup() {
+    print_status "Limpiando containers e imágenes..."
+    
+    # Parar todos los containers del proyecto
+    docker stop $(docker ps -q --filter "name=$DOCKER_USERNAME-$IMAGE_NAME") 2>/dev/null || true
+    
+    # Remover containers
+    docker rm $(docker ps -aq --filter "name=$DOCKER_USERNAME-$IMAGE_NAME") 2>/dev/null || true
+    
+    # Remover imágenes no utilizadas
+    docker image prune -f
+    
+    print_success "Limpieza completada"
+}
+
+# Función para mostrar estado
+status() {
+    print_status "Estado de containers GPT Local:"
+    
+    # Containers corriendo
+    echo "Containers corriendo:"
+    docker ps --filter "name=$DOCKER_USERNAME-$IMAGE_NAME" --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"
+    
+    echo ""
+    echo "Imágenes disponibles:"
+    docker images --filter "reference=$DOCKER_USERNAME/$IMAGE_NAME" --format "table {{.Repository}}\t{{.Tag}}\t{{.Size}}\t{{.CreatedSince}}"
+    
+    echo ""
+    echo "Uso de espacio Docker:"
+    docker system df
+}
+
+# Función principal
+main() {
+    local action=${1:-"help"}
+    local param=${2:-"latest"}
+    
+    case $action in
+        "build")
+            build_image
+            ;;
+        "push")
+            build_image
+            push_image
+            ;;
+        "run")
+            run_container "$param"
+            ;;
+        "compose")
+            run_compose "$param"
+            ;;
+        "cleanup")
+            cleanup
+            ;;
+        "status")
+            status
+            ;;
+        "full")
+            build_image
+            push_image
+            print_status "🎉 Pipeline completo ejecutado!"
+            ;;
+        *)
+            echo "🐳 Script de gestión Docker para GPT Local"
+            echo ""
+            echo "Uso: $0 [comando] [parámetro]"
+            echo ""
+            echo "Comandos:"
+            echo "  build                - Construir imagen Docker"
+            echo "  push                 - Construir y subir a Docker Hub"
+            echo "  run [web|terminal|dev] - Ejecutar container"
+            echo "  compose [service]    - Ejecutar con docker-compose"
+            echo "  cleanup              - Limpiar containers e imágenes"
+            echo "  status               - Mostrar estado actual"
+            echo "  full                 - Pipeline completo (build + push)"
+            echo ""
+            echo "Ejemplos:"
+            echo "  $0 build             # Construir imagen"
+            echo "  $0 push              # Construir y subir"
+            echo "  $0 run web           # Ejecutar interfaz web"
+            echo "  $0 run terminal      # Ejecutar chat terminal"
+            echo "  $0 compose           # Ejecutar con docker-compose"
+            echo ""
+            echo "Variables de entorno (archivo .env):"
+            echo "  DOCKER_USERNAME=$DOCKER_USERNAME"
+            echo "  DOCKER_IMAGE_NAME=$IMAGE_NAME"
+            echo "  HUGGINGFACE_TOKEN=***"
+            ;;
+    esac
+}
+
+# Ejecutar script
+main "$@"

environment.yml

@@ -0,0 +1,21 @@
+# Conda environment file for GPT Local
+name: gpt-local
+channels:
+  - pytorch
+  - conda-forge
+  - defaults
+dependencies:
+  - python=3.9
+  - pytorch>=2.0.0
+  - pytorch-cpu  # or pytorch-cuda for GPU
+  - pip
+  - pip:
+    - transformers>=4.21.0
+    - gradio>=3.50.0
+    - accelerate>=0.20.0
+    - sentencepiece>=0.1.99
+    - numpy>=1.21.0
+    - pandas>=1.3.0
+    - matplotlib>=3.5.0
+    - requests>=2.25.0
+    - tqdm>=4.60.0

main.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+"""
+GPT Local - Aplicación principal
+Ejecuta el GPT de texto local con interfaz web
+"""
+
+import sys
+import logging
+from pathlib import Path
+
+# Agregar el directorio raíz al path
+sys.path.append(str(Path(__file__).parent))
+
+from ui.gradio_interface import GradioInterface
+from config.settings import WEB_CONFIG, LOGGING_CONFIG
+
+def setup_logging():
+    """Configurar el sistema de logging"""
+    logging.basicConfig(
+        level=getattr(logging, LOGGING_CONFIG["level"]),
+        format=LOGGING_CONFIG["format"]
+    )
+
+def main():
+    """Función principal"""
+    # Configurar logging
+    setup_logging()
+    logger = logging.getLogger(__name__)
+    
+    logger.info("🚀 Iniciando GPT Local...")
+    logger.info(f"Configuración: {WEB_CONFIG}")
+    
+    try:
+        # Crear e iniciar la interfaz
+        interface = GradioInterface()
+        
+        logger.info("🌐 Lanzando interfaz web...")
+        interface.launch(
+            server_name=WEB_CONFIG["host"],
+            server_port=WEB_CONFIG["port"],
+            share=WEB_CONFIG["share"],
+            debug=WEB_CONFIG["debug"]
+        )
+        
+    except KeyboardInterrupt:
+        logger.info("👋 Aplicación detenida por el usuario")
+    except Exception as e:
+        logger.error(f"❌ Error al ejecutar la aplicación: {str(e)}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

manage-repos.sh

@@ -0,0 +1,335 @@
+#!/bin/bash
+# 🔧 Script de gestión de repositorios para GPT Local
+# Automatiza la creación y configuración de repositorios en GitHub y Hugging Face
+
+set -e
+
+# Cargar variables de entorno
+if [ -f .env ]; then
+    export $(cat .env | grep -v '^#' | xargs)
+fi
+
+# Colores para output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+print_status() {
+    echo -e "${BLUE}[INFO]${NC} $1"
+}
+
+print_success() {
+    echo -e "${GREEN}[SUCCESS]${NC} $1"
+}
+
+print_warning() {
+    echo -e "${YELLOW}[WARNING]${NC} $1"
+}
+
+print_error() {
+    echo -e "${RED}[ERROR]${NC} $1"
+}
+
+# Función para crear repositorio en GitHub
+create_github_repo() {
+    local repo_name=${1:-"gpt-local"}
+    local description="🤖 Sistema de chat GPT local con Hugging Face - Soporte Docker, CLI y múltiples modelos"
+    
+    print_status "Creando repositorio en GitHub: $repo_name"
+    
+    # Verificar autenticación
+    if ! gh auth status &> /dev/null; then
+        print_error "GitHub CLI no está autenticado"
+        print_status "Ejecuta: gh auth login --with-token"
+        return 1
+    fi
+    
+    # Crear repositorio
+    if gh repo create "$repo_name" --description "$description" --public --clone=false; then
+        print_success "Repositorio '$repo_name' creado en GitHub"
+        
+        # Configurar remoto
+        if git remote | grep -q "origin"; then
+            git remote set-url origin "https://github.com/$(gh api user --jq .login)/$repo_name.git"
+        else
+            git remote add origin "https://github.com/$(gh api user --jq .login)/$repo_name.git"
+        fi
+        
+        print_success "Remoto configurado"
+        return 0
+    else
+        print_warning "El repositorio puede ya existir o hubo un error"
+        return 1
+    fi
+}
+
+# Función para crear repositorio en Hugging Face
+create_huggingface_repo() {
+    local repo_name=${1:-"gpt-local"}
+    local repo_type=${2:-"space"}  # space, model, dataset
+    
+    print_status "Creando repositorio en Hugging Face: $repo_name"
+    
+    # Verificar token
+    if [ -z "$HUGGINGFACE_TOKEN" ]; then
+        print_error "Token de Hugging Face no configurado"
+        print_status "Configura HUGGINGFACE_TOKEN en .env"
+        return 1
+    fi
+    
+    # Crear repositorio usando API
+    case $repo_type in
+        "space")
+            print_status "Creando Hugging Face Space..."
+            if huggingface-cli upload . . --repo-id "$(huggingface-cli whoami | head -1)/$repo_name" --repo-type space --create; then
+                print_success "Hugging Face Space creado: https://huggingface.co/spaces/$(huggingface-cli whoami | head -1)/$repo_name"
+            else
+                print_warning "Error creando Space o ya existe"
+            fi
+            ;;
+        "model")
+            print_status "Creando repositorio de modelo..."
+            # Para modelos fine-tuneados
+            ;;
+        "dataset")
+            print_status "Creando repositorio de dataset..."
+            # Para datasets personalizados
+            ;;
+    esac
+}
+
+# Función para configurar git
+setup_git() {
+    print_status "Configurando Git..."
+    
+    # Inicializar si no existe
+    if [ ! -d ".git" ]; then
+        git init
+        print_success "Repositorio Git inicializado"
+    fi
+    
+    # Configurar gitignore si no existe
+    if [ ! -f ".gitignore" ]; then
+        cat > .gitignore << 'EOF'
+# Tokens y configuración sensible
+.env
+*.token
+.cache/
+.secrets/
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Modelos y cache
+models_cache/
+models/*/
+*.bin
+*.safetensors
+.cache/
+huggingface_cache/
+
+# Logs
+*.log
+logs/
+.logs/
+
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Docker
+.docker/
+docker-data/
+
+# Jupyter
+.ipynb_checkpoints/
+*.ipynb
+
+# Test coverage
+htmlcov/
+.coverage
+.coverage.*
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+EOF
+        print_success "Archivo .gitignore creado"
+    fi
+    
+    # Agregar archivos
+    git add .
+    
+    # Commit inicial si no hay commits
+    if ! git log --oneline -1 &> /dev/null; then
+        git commit -m "🚀 Initial commit: GPT Local project setup
+
+- ✅ Complete project structure with models, UI, and config
+- ✅ Docker support with multi-service configuration  
+- ✅ Hugging Face and GitHub integration
+- ✅ Python CLI tools and utilities
+- ✅ Multiple model support (DialoGPT, Mistral, Gemma)
+- ✅ Terminal and web chat interfaces
+- ✅ Apple Silicon MPS optimization
+- ✅ Comprehensive documentation and setup scripts"
+        print_success "Commit inicial creado"
+    fi
+}
+
+# Función para hacer push completo
+push_to_github() {
+    print_status "Subiendo código a GitHub..."
+    
+    # Verificar que tenemos remoto
+    if ! git remote | grep -q "origin"; then
+        print_error "No hay remoto configurado. Ejecuta create_github_repo primero"
+        return 1
+    fi
+    
+    # Push
+    if git push -u origin main 2>/dev/null || git push -u origin master 2>/dev/null; then
+        print_success "Código subido a GitHub exitosamente"
+        
+        # Mostrar URL del repositorio
+        local repo_url=$(git remote get-url origin | sed 's/\.git$//')
+        print_status "Repositorio disponible en: $repo_url"
+    else
+        print_error "Error subiendo a GitHub"
+        return 1
+    fi
+}
+
+# Función para crear README de Hugging Face Space
+create_huggingface_readme() {
+    cat > README_HF.md << 'EOF'
+---
+title: GPT Local Chat
+emoji: 🤖
+colorFrom: blue
+colorTo: green
+sdk: gradio
+sdk_version: 4.44.1
+app_file: main.py
+pinned: false
+license: mit
+tags:
+  - chatbot
+  - gpt
+  - huggingface
+  - pytorch
+  - transformers
+  - gradio
+  - spanish
+  - conversational-ai
+---
+
+# 🤖 GPT Local Chat
+
+Un sistema de chat GPT local potenciado por modelos de Hugging Face.
+
+## Características
+
+- 💬 Chat conversacional en tiempo real
+- 🤗 Múltiples modelos de Hugging Face
+- 🍎 Optimizado para Apple Silicon (MPS)
+- ⚡ GPU acceleration automática
+- 🌐 Interfaz web moderna con Gradio
+
+## Modelos Soportados
+
+- DialoGPT (small/medium/large)
+- Mistral 7B Instruct
+- Google Gemma 2B
+
+## Uso
+
+Simplemente escribe tu mensaje y presiona Enter para chatear con el modelo.
+
+## Código Fuente
+
+El código completo está disponible en: [GitHub Repository](https://github.com/tu-usuario/gpt-local)
+EOF
+    print_success "README de Hugging Face creado"
+}
+
+# Función principal
+main() {
+    local action=${1:-"full"}
+    local repo_name=${2:-"gpt-local"}
+    
+    print_status "🚀 Iniciando gestión de repositorios..."
+    
+    case $action in
+        "github")
+            setup_git
+            create_github_repo "$repo_name"
+            push_to_github
+            ;;
+        "huggingface")
+            create_huggingface_readme
+            create_huggingface_repo "$repo_name" "space"
+            ;;
+        "full")
+            setup_git
+            create_github_repo "$repo_name"
+            push_to_github
+            create_huggingface_readme
+            create_huggingface_repo "$repo_name" "space"
+            ;;
+        "setup")
+            setup_git
+            ;;
+        "push")
+            push_to_github
+            ;;
+        *)
+            echo "Uso: $0 [github|huggingface|full|setup|push] [nombre_repo]"
+            echo ""
+            echo "Comandos:"
+            echo "  github      - Crear solo repositorio GitHub"
+            echo "  huggingface - Crear solo Hugging Face Space"
+            echo "  full        - Crear ambos repositorios"
+            echo "  setup       - Solo configurar Git local"
+            echo "  push        - Solo subir cambios a GitHub"
+            exit 1
+            ;;
+    esac
+    
+    print_success "✅ Gestión de repositorios completada!"
+}
+
+# Ejecutar script
+main "$@"

models/__init__.py

@@ -0,0 +1 @@
+# Módulo de modelos para GPT Local

models/model_loader.py

@@ -0,0 +1,72 @@
+"""
+Cargador de modelos GPT para uso local
+"""
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+import logging
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class ModelLoader:
+    def __init__(self):
+        self.model = None
+        self.tokenizer = None
+        # Optimización para Apple Silicon
+        if torch.backends.mps.is_available():
+            self.device = "mps"
+        elif torch.cuda.is_available():
+            self.device = "cuda"
+        else:
+            self.device = "cpu"
+        
+    def load_model(self, model_name="microsoft/DialoGPT-medium"):
+        """
+        Carga un modelo GPT desde Hugging Face
+        
+        Args:
+            model_name (str): Nombre del modelo en Hugging Face Hub
+        """
+        try:
+            logger.info(f"Cargando modelo: {model_name}")
+            logger.info(f"Usando dispositivo: {self.device}")
+            
+            # Cargar tokenizer
+            self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+            
+            # Agregar pad_token si no existe
+            if self.tokenizer.pad_token is None:
+                self.tokenizer.pad_token = self.tokenizer.eos_token
+            
+            # Cargar modelo
+            self.model = AutoModelForCausalLM.from_pretrained(
+                model_name,
+                torch_dtype=torch.float16 if self.device == "cuda" else torch.float32,
+                device_map="auto" if self.device == "cuda" else None
+            )
+            
+            if self.device == "cpu":
+                self.model = self.model.to(self.device)
+            
+            logger.info("Modelo cargado exitosamente")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Error al cargar el modelo: {str(e)}")
+            return False
+    
+    def get_model_info(self):
+        """Retorna información del modelo cargado"""
+        if self.model is None:
+            return {"status": "No hay modelo cargado"}
+        
+        return {
+            "status": "Modelo cargado",
+            "device": self.device,
+            "model_type": type(self.model).__name__,
+            "vocab_size": self.tokenizer.vocab_size if self.tokenizer else "N/A"
+        }
+    
+    def is_loaded(self):
+        """Verifica si hay un modelo cargado"""
+        return self.model is not None and self.tokenizer is not None

models/text_generator.py

@@ -0,0 +1,139 @@
+"""
+Generador de texto usando modelos GPT locales
+"""
+import torch
+from typing import List, Dict
+import logging
+
+logger = logging.getLogger(__name__)
+
+class TextGenerator:
+    def __init__(self, model_loader):
+        self.model_loader = model_loader
+        self.chat_history_ids = None
+        
+    def generate_response(self, user_input: str, **kwargs) -> str:
+        """
+        Genera una respuesta basada en la entrada del usuario
+        
+        Args:
+            user_input (str): Mensaje del usuario
+            **kwargs: Parámetros de generación (max_length, temperature, etc.)
+        
+        Returns:
+            str: Respuesta generada
+        """
+        if not self.model_loader.is_loaded():
+            return "Error: No hay modelo cargado"
+        
+        try:
+            # Parámetros por defecto
+            max_length = kwargs.get('max_length', 512)
+            temperature = kwargs.get('temperature', 0.7)
+            top_p = kwargs.get('top_p', 0.9)
+            do_sample = kwargs.get('do_sample', True)
+            
+            # Codificar la entrada del usuario
+            new_user_input_ids = self.model_loader.tokenizer.encode(
+                user_input + self.model_loader.tokenizer.eos_token, 
+                return_tensors='pt'
+            ).to(self.model_loader.device)
+            
+            # Concatenar con el historial de chat
+            if self.chat_history_ids is not None:
+                bot_input_ids = torch.cat([self.chat_history_ids, new_user_input_ids], dim=-1)
+            else:
+                bot_input_ids = new_user_input_ids
+            
+            # Generar respuesta
+            with torch.no_grad():
+                chat_history_ids = self.model_loader.model.generate(
+                    bot_input_ids,
+                    max_length=max_length,
+                    num_beams=1,
+                    do_sample=do_sample,
+                    temperature=temperature,
+                    top_p=top_p,
+                    pad_token_id=self.model_loader.tokenizer.eos_token_id,
+                    attention_mask=torch.ones(bot_input_ids.shape, device=self.model_loader.device)
+                )
+            
+            # Actualizar historial
+            self.chat_history_ids = chat_history_ids
+            
+            # Decodificar solo la nueva respuesta
+            response = self.model_loader.tokenizer.decode(
+                chat_history_ids[:, bot_input_ids.shape[-1]:][0], 
+                skip_special_tokens=True
+            )
+            
+            return str(response).strip()
+            
+        except Exception as e:
+            logger.error(f"Error en la generación: {str(e)}")
+            return f"Error al generar respuesta: {str(e)}"
+    
+    def generate_text(self, prompt: str, **kwargs) -> str:
+        """
+        Genera texto continuando un prompt (sin historial de chat)
+        
+        Args:
+            prompt (str): Texto inicial
+            **kwargs: Parámetros de generación
+        
+        Returns:
+            str: Texto generado
+        """
+        if not self.model_loader.is_loaded():
+            return "Error: No hay modelo cargado"
+        
+        try:
+            # Parámetros por defecto
+            max_length = kwargs.get('max_length', 100)
+            temperature = kwargs.get('temperature', 0.8)
+            top_p = kwargs.get('top_p', 0.9)
+            do_sample = kwargs.get('do_sample', True)
+            
+            # Codificar el prompt
+            input_ids = self.model_loader.tokenizer.encode(
+                prompt, 
+                return_tensors='pt'
+            ).to(self.model_loader.device)
+            
+            # Generar texto
+            with torch.no_grad():
+                output = self.model_loader.model.generate(
+                    input_ids,
+                    max_length=input_ids.shape[1] + max_length,
+                    do_sample=do_sample,
+                    temperature=temperature,
+                    top_p=top_p,
+                    pad_token_id=self.model_loader.tokenizer.eos_token_id,
+                    attention_mask=torch.ones(input_ids.shape, device=self.model_loader.device)
+                )
+            
+            # Decodificar solo el texto generado
+            generated_text = self.model_loader.tokenizer.decode(
+                output[0][input_ids.shape[1]:], 
+                skip_special_tokens=True
+            )
+            
+            return str(generated_text.strip())
+            
+        except Exception as e:
+            logger.error(f"Error en la generación: {str(e)}")
+            return f"Error al generar texto: {str(e)}"
+    
+    def reset_chat_history(self):
+        """Reinicia el historial de chat"""
+        self.chat_history_ids = None
+        logger.info("Historial de chat reiniciado")
+    
+    def get_generation_stats(self) -> Dict:
+        """Retorna estadísticas de generación"""
+        if self.chat_history_ids is not None:
+            return {
+                "history_length": self.chat_history_ids.shape[1],
+                "device": str(self.chat_history_ids.device)
+            }
+        return {"history_length": 0, "device": "N/A"}

mypy.ini

@@ -0,0 +1,34 @@
+[mypy]
+python_version = 3.9
+warn_return_any = True
+warn_unused_configs = True
+disallow_untyped_defs = False
+disallow_incomplete_defs = False
+check_untyped_defs = True
+disallow_untyped_decorators = False
+no_implicit_optional = True
+warn_redundant_casts = True
+warn_unused_ignores = True
+warn_no_return = True
+warn_unreachable = True
+ignore_missing_imports = True
+strict_optional = False
+
+# Ignorar errores específicos de módulos externos
+[mypy-transformers.*]
+ignore_missing_imports = True
+
+[mypy-gradio.*]
+ignore_missing_imports = True
+
+[mypy-torch.*]
+ignore_missing_imports = True
+
+[mypy-models.*]
+ignore_missing_imports = True
+
+[mypy-ui.*]
+ignore_missing_imports = True
+
+[mypy-config.*]
+ignore_missing_imports = True

package.json

@@ -0,0 +1,43 @@
+{
+  "name": "gpt-local",
+  "version": "1.0.0",
+  "description": "GPT de texto local usando Hugging Face Transformers",
+  "main": "main.py",
+  "scripts": {
+    "start": "python3 main.py",
+    "chat": "python3 chat_terminal.py",
+    "test": "python3 test_gpt.py",
+    "install": "pip3 install -r requirements.txt",
+    "docker:build": "docker build -t gpt-local .",
+    "docker:run": "docker run -it -p 7860:7860 gpt-local",
+    "docker:compose": "docker-compose up",
+    "clean": "find . -name '__pycache__' -type d -exec rm -rf {} + 2>/dev/null || true"
+  },
+  "keywords": [
+    "gpt",
+    "transformers",
+    "huggingface",
+    "local",
+    "ai",
+    "nlp",
+    "chat",
+    "python"
+  ],
+  "author": "Usuario Local",
+  "license": "MIT",
+  "dependencies": {
+    "python": ">=3.8"
+  },
+  "engines": {
+    "python": ">=3.8"
+  },
+  "repository": {
+    "type": "git",
+    "url": "local"
+  },
+  "config": {
+    "model_cache": "~/.cache/huggingface",
+    "default_model": "microsoft/DialoGPT-small",
+    "web_port": 7860
+  }
+}

requirements-dev.txt

@@ -0,0 +1,24 @@
+# Development dependencies (opcional)
+torch>=2.0.0
+transformers>=4.21.0
+gradio>=3.50.0,<5.0.0
+accelerate>=0.20.0
+sentencepiece>=0.1.99
+
+# Core ML dependencies
+numpy>=1.21.0,<2.0.0
+pandas>=1.3.0,<3.0.0
+matplotlib>=3.5.0,<4.0.0
+requests>=2.25.0,<3.0.0
+tqdm>=4.60.0,<5.0.0
+
+# Development tools (opcional)
+jupyter>=1.0.0
+ipython>=7.0.0
+black>=22.0.0
+flake8>=4.0.0
+pytest>=6.0.0
+
+# Optional GPU support
+# torch-audio  # descomenta si necesitas audio
+# torchvision  # descomenta si necesitas visión por computadora

requirements.txt

@@ -0,0 +1,10 @@
+# Dependencias principales
+torch>=2.0.0,<3.0.0
+transformers>=4.21.0,<5.0.0
+gradio>=4.0.0,<5.0.0
+accelerate>=0.20.0,<1.0.0
+sentencepiece>=0.1.99,<1.0.0
+
+# Dependencias adicionales para estabilidad
+numpy>=1.21.0,<2.0.0
+typing-extensions>=4.0.0

setup-cli.sh

@@ -0,0 +1,206 @@
+#!/bin/bash
+# 🔧 Script de configuración para CLI tools
+# Configura Hugging Face CLI, Docker CLI y GitHub CLI
+
+set -e
+
+echo "🚀 Configurando CLI Tools para GPT Local..."
+
+# Colores para output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Función para imprimir con colores
+print_status() {
+    echo -e "${BLUE}[INFO]${NC} $1"
+}
+
+print_success() {
+    echo -e "${GREEN}[SUCCESS]${NC} $1"
+}
+
+print_warning() {
+    echo -e "${YELLOW}[WARNING]${NC} $1"
+}
+
+print_error() {
+    echo -e "${RED}[ERROR]${NC} $1"
+}
+
+# 1. Instalar Hugging Face CLI
+install_huggingface_cli() {
+    print_status "Instalando Hugging Face CLI..."
+    
+    if command -v huggingface-cli &> /dev/null; then
+        print_success "Hugging Face CLI ya está instalado"
+    else
+        pip install --upgrade huggingface_hub
+        print_success "Hugging Face CLI instalado"
+    fi
+    
+    # Verificar instalación
+    huggingface-cli --version || print_warning "Error verificando Hugging Face CLI"
+}
+
+# 2. Configurar Docker CLI (verificar instalación)
+check_docker() {
+    print_status "Verificando Docker CLI..."
+    
+    if command -v docker &> /dev/null; then
+        print_success "Docker CLI encontrado: $(docker --version)"
+        
+        # Verificar que Docker daemon esté ejecutándose
+        if docker info &> /dev/null; then
+            print_success "Docker daemon está ejecutándose"
+        else
+            print_warning "Docker CLI instalado pero daemon no está ejecutándose"
+            print_status "Inicia Docker Desktop o el servicio Docker"
+        fi
+    else
+        print_error "Docker CLI no encontrado"
+        print_status "Instala Docker desde: https://docs.docker.com/get-docker/"
+        exit 1
+    fi
+}
+
+# 3. Instalar GitHub CLI (opcional)
+install_github_cli() {
+    print_status "Verificando GitHub CLI..."
+    
+    if command -v gh &> /dev/null; then
+        print_success "GitHub CLI ya está instalado: $(gh --version | head -1)"
+    else
+        print_warning "GitHub CLI no encontrado"
+        print_status "Instalando GitHub CLI..."
+        
+        # Detectar OS y instalar apropiadamente
+        if [[ "$OSTYPE" == "darwin"* ]]; then
+            # macOS
+            if command -v brew &> /dev/null; then
+                brew install gh
+                print_success "GitHub CLI instalado via Homebrew"
+            else
+                print_warning "Homebrew no encontrado. Instala manualmente desde: https://cli.github.com/"
+            fi
+        elif [[ "$OSTYPE" == "linux-gnu"* ]]; then
+            # Linux
+            curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | sudo dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg
+            echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null
+            sudo apt update
+            sudo apt install gh
+            print_success "GitHub CLI instalado"
+        else
+            print_warning "OS no soportado para instalación automática. Instala manualmente desde: https://cli.github.com/"
+        fi
+    fi
+}
+
+# 4. Configurar autenticación de Hugging Face
+setup_huggingface_auth() {
+    print_status "Configurando autenticación de Hugging Face..."
+    
+    if [ -f "$HOME/.cache/huggingface/token" ]; then
+        print_success "Token de Hugging Face ya configurado"
+    else
+        print_warning "Token de Hugging Face no encontrado"
+        print_status "Para configurar tu token:"
+        echo "1. Ve a: https://huggingface.co/settings/tokens"
+        echo "2. Crea un nuevo token con permisos de lectura"
+        echo "3. Ejecuta: huggingface-cli login"
+        echo "4. O agrega el token al archivo .env: HUGGINGFACE_TOKEN=hf_tu_token"
+    fi
+}
+
+# 5. Configurar autenticación de GitHub
+setup_github_auth() {
+    print_status "Configurando autenticación de GitHub..."
+    
+    if command -v gh &> /dev/null; then
+        if gh auth status &> /dev/null; then
+            print_success "GitHub CLI ya está autenticado"
+        else
+            print_warning "GitHub CLI no está autenticado"
+            print_status "Para autenticar ejecuta: gh auth login"
+        fi
+    else
+        print_warning "GitHub CLI no instalado, saltando configuración"
+    fi
+}
+
+# 6. Verificar Docker Compose
+check_docker_compose() {
+    print_status "Verificando Docker Compose..."
+    
+    if command -v docker-compose &> /dev/null; then
+        print_success "Docker Compose encontrado: $(docker-compose --version)"
+    elif docker compose version &> /dev/null; then
+        print_success "Docker Compose (plugin) encontrado: $(docker compose version)"
+    else
+        print_error "Docker Compose no encontrado"
+        print_status "Instala Docker Compose desde: https://docs.docker.com/compose/install/"
+    fi
+}
+
+# 7. Crear alias útiles
+create_aliases() {
+    print_status "Creando aliases útiles..."
+    
+    cat >> ~/.bash_aliases 2>/dev/null << 'EOF' || true
+# GPT Local aliases
+alias gpt-chat="cd /path/to/gpt-local && python3 chat_terminal.py"
+alias gpt-web="cd /path/to/gpt-local && python3 main.py"
+alias gpt-test="cd /path/to/gpt-local && python3 test_gpt.py"
+alias gpt-docker="cd /path/to/gpt-local && docker-compose up --build"
+alias gpt-clean="cd /path/to/gpt-local && python3 utils.py clean"
+EOF
+    
+    # Para zsh
+    cat >> ~/.zshrc 2>/dev/null << 'EOF' || true
+# GPT Local aliases
+alias gpt-chat="cd /path/to/gpt-local && python3 chat_terminal.py"
+alias gpt-web="cd /path/to/gpt-local && python3 main.py"
+alias gpt-test="cd /path/to/gpt-local && python3 test_gpt.py"
+alias gpt-docker="cd /path/to/gpt-local && docker-compose up --build"
+alias gpt-clean="cd /path/to/gpt-local && python3 utils.py clean"
+EOF
+    
+    print_success "Aliases creados (recarga tu terminal para usarlos)"
+}
+
+# Función principal
+main() {
+    print_status "Iniciando configuración de CLI tools..."
+    
+    # Verificar Python
+    if ! command -v python3 &> /dev/null; then
+        print_error "Python 3 no encontrado. Instala Python 3.9+"
+        exit 1
+    fi
+    
+    # Ejecutar configuraciones
+    install_huggingface_cli
+    check_docker
+    check_docker_compose
+    install_github_cli
+    setup_huggingface_auth
+    setup_github_auth
+    create_aliases
+    
+    print_success "✅ Configuración de CLI tools completada!"
+    print_status "Comandos disponibles:"
+    echo "  - huggingface-cli: Gestión de modelos HF"
+    echo "  - docker: Containerización"
+    echo "  - docker-compose: Orquestación"
+    echo "  - gh: GitHub CLI (opcional)"
+    
+    print_status "Próximos pasos:"
+    echo "1. Configura tu token HF: huggingface-cli login"
+    echo "2. Autentica GitHub (opcional): gh auth login"
+    echo "3. Ejecuta: docker-compose up --build"
+}
+
+# Ejecutar script
+main "$@"

setup.sh

@@ -0,0 +1,53 @@
+#!/bin/bash
+
+# Script de instalación y configuración para GPT Local
+
+echo "🚀 Configurando GPT Local..."
+
+# Verificar Python
+echo "🐍 Verificando Python..."
+if ! command -v python3 &> /dev/null; then
+    echo "❌ Python3 no encontrado. Instálalo primero."
+    exit 1
+fi
+
+echo "✅ Python encontrado: $(python3 --version)"
+
+# Crear entorno virtual (opcional)
+read -p "¿Crear entorno virtual? (y/N): " create_venv
+if [[ $create_venv =~ ^[Yy]$ ]]; then
+    echo "📦 Creando entorno virtual..."
+    python3 -m venv venv
+    source venv/bin/activate
+    echo "✅ Entorno virtual activado"
+fi
+
+# Instalar dependencias
+echo "📦 Instalando dependencias..."
+pip3 install -r requirements.txt
+
+# Verificar instalación
+echo "🔍 Verificando instalación..."
+python3 -c "
+import torch, transformers, gradio
+print('✅ Todas las dependencias instaladas')
+print(f'PyTorch: {torch.__version__}')
+print(f'Transformers: {transformers.__version__}')
+print(f'Gradio: {gradio.__version__}')
+"
+
+# Crear directorios necesarios
+echo "📁 Creando directorios..."
+mkdir -p models_cache
+mkdir -p logs
+
+# Prueba rápida
+echo "🧪 Ejecutando prueba..."
+python3 test_gpt.py
+
+echo "🎉 ¡Configuración completada!"
+echo ""
+echo "Para ejecutar:"
+echo "  Chat en terminal: python3 chat_terminal.py"
+echo "  Interfaz web: python3 main.py"
+echo "  Utilidades: python3 utils.py check"

test_gpt.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+"""
+Script de prueba para verificar que el GPT Local funciona
+"""
+
+import sys
+from pathlib import Path
+
+# Agregar el directorio raíz al path
+sys.path.append(str(Path(__file__).parent))
+
+try:
+    from models.model_loader import ModelLoader
+    from models.text_generator import TextGenerator
+    
+    print("🚀 Probando GPT Local...")
+    
+    # Inicializar componentes
+    model_loader = ModelLoader()
+    text_generator = TextGenerator(model_loader)
+    
+    # Cargar modelo pequeño
+    print("📦 Cargando modelo DialoGPT-small...")
+    success = model_loader.load_model("microsoft/DialoGPT-small")
+    
+    if success:
+        print("✅ Modelo cargado exitosamente")
+        
+        # Prueba básica
+        test_message = "Hola"
+        print(f"🧪 Probando con: '{test_message}'")
+        
+        response = text_generator.generate_response(test_message, max_length=50)
+        print(f"🤖 Respuesta: {response}")
+        
+        print("\n✅ ¡GPT Local funcionando correctamente!")
+        
+    else:
+        print("❌ Error al cargar el modelo")
+        
+except Exception as e:
+    print(f"❌ Error: {str(e)}")
+    import traceback
+    traceback.print_exc()

ui/__init__.py

@@ -0,0 +1 @@
+# Módulo de interfaz de usuario

ui/gradio_interface.py

@@ -0,0 +1,158 @@
+"""
+Interfaz web usando Gradio para el GPT local
+"""
+import gradio as gr
+from models.model_loader import ModelLoader
+from models.text_generator import TextGenerator
+import logging
+
+logger = logging.getLogger(__name__)
+
+class GradioInterface:
+    def __init__(self):
+        self.model_loader = ModelLoader()
+        self.text_generator = TextGenerator(self.model_loader)
+        self.available_models = [
+            "microsoft/DialoGPT-small",
+            "gpt2",
+            "distilgpt2"
+        ]
+        
+    def load_model_ui(self, model_name):
+        """Cargar modelo desde la interfaz"""
+        if self.model_loader.load_model(model_name):
+            self.text_generator.reset_chat_history()
+            return f"✅ Modelo '{model_name}' cargado exitosamente"
+        else:
+            return f"❌ Error al cargar el modelo '{model_name}'"
+    
+    def chat_response(self, message, history, temperature, max_length, top_p):
+        """Generar respuesta de chat"""
+        if not self.model_loader.is_loaded():
+            return history + [("Error", "Por favor, carga un modelo primero")]
+        
+        try:
+            # Generar respuesta
+            response = self.text_generator.generate_response(
+                message,
+                temperature=temperature,
+                max_length=max_length,
+                top_p=top_p
+            )
+            
+            # Actualizar historial
+            history.append((message, response))
+            return history
+            
+        except Exception as e:
+            error_msg = f"Error: {str(e)}"
+            history.append((message, error_msg))
+            return history
+    
+    def generate_text_ui(self, prompt, temperature, max_length, top_p):
+        """Generar texto desde prompt"""
+        if not self.model_loader.is_loaded():
+            return "Error: Por favor, carga un modelo primero"
+        
+        return self.text_generator.generate_text(
+            prompt,
+            temperature=temperature,
+            max_length=max_length,
+            top_p=top_p
+        )
+    
+    def reset_chat(self):
+        """Reiniciar chat"""
+        self.text_generator.reset_chat_history()
+        return [], "Chat reiniciado"
+    
+    def get_model_status(self):
+        """Obtener estado del modelo"""
+        info = self.model_loader.get_model_info()
+        stats = self.text_generator.get_generation_stats()
+        
+        status = f"""
+**Estado del Modelo:**
+- {info['status']}
+- Dispositivo: {info.get('device', 'N/A')}
+- Tipo: {info.get('model_type', 'N/A')}
+- Vocabulario: {info.get('vocab_size', 'N/A')}
+
+**Estadísticas de Chat:**
+- Longitud del historial: {stats['history_length']} tokens
+- Dispositivo activo: {stats['device']}
+        """
+        return status
+    
+    def create_interface(self):
+        """Crear la interfaz Gradio simplificada"""
+        
+        with gr.Blocks(title="GPT Local") as demo:
+            gr.Markdown("# 🤖 GPT Local con Hugging Face")
+            
+            with gr.Tab("💬 Chat"):
+                chatbot = gr.Chatbot(height=400)
+                msg = gr.Textbox(placeholder="Escribe tu mensaje...", label="Mensaje")
+                
+                with gr.Row():
+                    send_btn = gr.Button("Enviar", variant="primary")
+                    clear_btn = gr.Button("Limpiar")
+                
+                # Parámetros básicos
+                with gr.Row():
+                    temperature = gr.Slider(0.1, 2.0, 0.7, label="Temperatura")
+                    max_length = gr.Slider(50, 500, 200, label="Longitud Máxima")
+            
+            with gr.Tab("⚙️ Configuración"):
+                model_dropdown = gr.Dropdown(
+                    choices=self.available_models,
+                    value=self.available_models[0],
+                    label="Modelo"
+                )
+                load_btn = gr.Button("Cargar Modelo")
+                status_text = gr.Textbox(label="Estado", interactive=False)
+            
+            # Event handlers simplificados
+            def respond(message, history, temp, max_len):
+                if not message.strip():
+                    return history, ""
+                
+                try:
+                    response = self.text_generator.generate_response(
+                        message, temperature=temp, max_length=max_len
+                    )
+                    history.append((message, response))
+                    return history, ""
+                except Exception as e:
+                    history.append((message, f"Error: {str(e)}"))
+                    return history, ""
+            
+            def load_model(model_name):
+                try:
+                    if self.model_loader.load_model(model_name):
+                        self.text_generator.reset_chat_history()
+                        return f"✅ Modelo '{model_name}' cargado"
+                    else:
+                        return f"❌ Error al cargar '{model_name}'"
+                except Exception as e:
+                    return f"❌ Error: {str(e)}"
+            
+            def clear_chat():
+                self.text_generator.reset_chat_history()
+                return []
+            
+            # Conectar eventos
+            msg.submit(respond, [msg, chatbot, temperature, max_length], [chatbot, msg])
+            send_btn.click(respond, [msg, chatbot, temperature, max_length], [chatbot, msg])
+            clear_btn.click(clear_chat, outputs=chatbot)
+            load_btn.click(load_model, model_dropdown, status_text)
+            
+            # Cargar modelo por defecto
+            demo.load(lambda: load_model(self.available_models[0]), outputs=status_text)
+        
+        return demo
+    
+    def launch(self, **kwargs):
+        """Lanzar la interfaz"""
+        demo = self.create_interface()
+        demo.launch(**kwargs)

utils.py

@@ -0,0 +1,137 @@
+#!/usr/bin/env python3
+"""
+Script de utilidades para GPT Local
+Manejo de modelos, limpieza, actualización
+"""
+
+import sys
+import os
+import shutil
+import subprocess
+from pathlib import Path
+
+def check_environment():
+    """Verificar el entorno y dependencias"""
+    print("🔍 Verificando entorno...")
+    
+    try:
+        import torch
+        import transformers
+        import gradio as gr
+        print(f"✅ PyTorch: {torch.__version__}")
+        print(f"✅ Transformers: {transformers.__version__}")
+        print(f"✅ Gradio: {gr.__version__}")
+        print(f"✅ CUDA disponible: {torch.cuda.is_available()}")
+        print(f"✅ MPS disponible: {torch.backends.mps.is_available() if hasattr(torch.backends, 'mps') else 'N/A'}")
+        return True
+    except ImportError as e:
+        print(f"❌ Error de importación: {e}")
+        return False
+
+def clean_cache():
+    """Limpiar cache de modelos"""
+    print("🧹 Limpiando cache...")
+    
+    cache_dirs = [
+        Path.home() / ".cache" / "huggingface",
+        Path("models_cache"),
+        Path("__pycache__"),
+    ]
+    
+    for cache_dir in cache_dirs:
+        if cache_dir.exists():
+            size = sum(f.stat().st_size for f in cache_dir.rglob('*') if f.is_file())
+            print(f"📁 {cache_dir}: {size / (1024*1024*1024):.2f} GB")
+            
+            response = input(f"¿Eliminar {cache_dir}? (y/N): ")
+            if response.lower() == 'y':
+                shutil.rmtree(cache_dir)
+                print(f"✅ {cache_dir} eliminado")
+
+def install_dependencies():
+    """Instalar dependencias"""
+    print("📦 Instalando dependencias...")
+    subprocess.run([sys.executable, "-m", "pip", "install", "-r", "requirements.txt"])
+
+def update_dependencies():
+    """Actualizar dependencias"""
+    print("⬆️ Actualizando dependencias...")
+    subprocess.run([sys.executable, "-m", "pip", "install", "--upgrade", "-r", "requirements.txt"])
+
+def list_models():
+    """Listar modelos disponibles localmente"""
+    print("📋 Modelos disponibles:")
+    
+    cache_dir = Path.home() / ".cache" / "huggingface" / "hub"
+    if cache_dir.exists():
+        models = [d.name for d in cache_dir.iterdir() if d.is_dir()]
+        for model in models:
+            print(f"  - {model}")
+    else:
+        print("  No hay modelos en cache")
+
+def download_model(model_name):
+    """Descargar un modelo específico"""
+    print(f"⬇️ Descargando modelo: {model_name}")
+    
+    try:
+        from transformers import AutoTokenizer, AutoModelForCausalLM
+        
+        print("Descargando tokenizer...")
+        tokenizer = AutoTokenizer.from_pretrained(model_name)
+        
+        print("Descargando modelo...")
+        model = AutoModelForCausalLM.from_pretrained(model_name)
+        
+        print(f"✅ Modelo {model_name} descargado exitosamente")
+        
+    except Exception as e:
+        print(f"❌ Error al descargar: {e}")
+
+def show_usage():
+    """Mostrar información de uso"""
+    print("""
+🤖 GPT Local - Utilidades
+
+Comandos disponibles:
+  check     - Verificar entorno
+  clean     - Limpiar cache
+  install   - Instalar dependencias
+  update    - Actualizar dependencias  
+  models    - Listar modelos
+  download  - Descargar modelo específico
+  
+Ejemplos:
+  python3 utils.py check
+  python3 utils.py download microsoft/DialoGPT-small
+  python3 utils.py clean
+""")
+
+def main():
+    if len(sys.argv) < 2:
+        show_usage()
+        return
+    
+    command = sys.argv[1]
+    
+    if command == "check":
+        check_environment()
+    elif command == "clean":
+        clean_cache()
+    elif command == "install":
+        install_dependencies()
+    elif command == "update":
+        update_dependencies()
+    elif command == "models":
+        list_models()
+    elif command == "download":
+        if len(sys.argv) < 3:
+            print("❌ Especifica el nombre del modelo")
+            return
+        download_model(sys.argv[2])
+    else:
+        print(f"❌ Comando desconocido: {command}")
+        show_usage()
+
+if __name__ == "__main__":
+    main()