catalog-bot-os 0.1.0__tar.gz

catalog_bot_os-0.1.0/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: catalog-bot-os
+Version: 0.1.0
+Summary: Un Agente de IA local para catálogos SQL con Búsqueda Semántica 100% Inhackeable
+Home-page: https://github.com/tu-usuario/catalog-bot-os
+Author: Tu Nombre / Comunidad
+Author-email: tu_correo@ejemplo.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: typer==0.9.0
+Requires-Dist: rich==13.7.0
+Requires-Dist: sqlalchemy==2.0.25
+Requires-Dist: pymysql==1.1.0
+Requires-Dist: chromadb==0.4.22
+Requires-Dist: numpy<2.0.0
+Requires-Dist: fastapi
+Requires-Dist: uvicorn
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Catalog Bot OS 🤖
+
+¡Bienvenido a **Catalog Bot OS**! Un orquestador de IA Open Source diseñado para conectar tu base de datos SQL con modelos de lenguaje natural (RAG) de forma 100% local, privada e inhackeable.
+
+A diferencia de los frameworks pesados (como LangChain), este bot utiliza **ChromaDB** local para comprender sinónimos y consultas semánticas, conectándose directamente a tus tablas SQL sin exponerlas a inyecciones SQL.
+
+## 🚀 Instalación
+
+Puedes instalar el bot directamente desde PyPI usando pip:
+
+```bash
+pip install catalog-bot-os
+```
+
+## 🛠️ Guía de Uso Paso a Paso
+
+### 1. Inicialización
+Ve a la carpeta de tu proyecto y ejecuta el siguiente comando para generar el archivo de configuración. El sistema te guiará para ingresar las credenciales de tu base de datos.
+
+```bash
+catalog-bot init
+```
+
+*Esto creará un archivo oculto `.catalog-bot.json` en tu carpeta.*
+
+### 2. Mapeo de Tablas
+Una vez configurado, el bot necesita escanear las columnas de tu base de datos para entender el esquema.
+
+```bash
+catalog-bot map-schema
+```
+
+*Esto generará un archivo `schema_memory.json` con la radiografía de tus tablas permitidas.*
+
+### 3. Entrenamiento Semántico (RAG)
+Para que el bot "entienda" sinónimos (por ejemplo, saber que buscar "bebida" puede traer "gaseosa"), debes entrenar la memoria vectorial.
+Ejecuta el script de indexación en tu proyecto:
+
+```bash
+python semantic_indexer.py
+```
+*(Pronto este paso se integrará como `catalog-bot index`)*
+
+### 4. Levantar la API
+Levanta el servidor REST para conectar tu bot con cualquier Frontend (WhatsApp, React, etc.).
+
+```bash
+python api.py
+```
+
+Tu bot ahora estará escuchando peticiones en `http://localhost:8000/api/chat`. Puedes hacerle un POST con el siguiente JSON:
+
+```json
+{
+  "mensaje": "busco zapatos"
+}
+```
+
+## 🔒 Arquitectura de Seguridad
+- **Cero Inyecciones:** Usa parámetros `text()` de SQLAlchemy (Principio de Menor Privilegio).
+- **Enrutador Seguro:** Las peticiones maliciosas (ej. `DROP TABLE`) son bloqueadas antes de llegar a la base de datos.
+- **RAG Local:** Los datos no salen hacia OpenAI. Todo se procesa con ChromaDB localmente.
+
+## 🤝 Contribuciones
+¡Los PRs son bienvenidos! Este proyecto fue diseñado buscando los fundamentos sólidos y la soberanía de datos.

catalog_bot_os-0.1.0/README.md

@@ -0,0 +1,65 @@
+# Catalog Bot OS 🤖
+
+¡Bienvenido a **Catalog Bot OS**! Un orquestador de IA Open Source diseñado para conectar tu base de datos SQL con modelos de lenguaje natural (RAG) de forma 100% local, privada e inhackeable.
+
+A diferencia de los frameworks pesados (como LangChain), este bot utiliza **ChromaDB** local para comprender sinónimos y consultas semánticas, conectándose directamente a tus tablas SQL sin exponerlas a inyecciones SQL.
+
+## 🚀 Instalación
+
+Puedes instalar el bot directamente desde PyPI usando pip:
+
+```bash
+pip install catalog-bot-os
+```
+
+## 🛠️ Guía de Uso Paso a Paso
+
+### 1. Inicialización
+Ve a la carpeta de tu proyecto y ejecuta el siguiente comando para generar el archivo de configuración. El sistema te guiará para ingresar las credenciales de tu base de datos.
+
+```bash
+catalog-bot init
+```
+
+*Esto creará un archivo oculto `.catalog-bot.json` en tu carpeta.*
+
+### 2. Mapeo de Tablas
+Una vez configurado, el bot necesita escanear las columnas de tu base de datos para entender el esquema.
+
+```bash
+catalog-bot map-schema
+```
+
+*Esto generará un archivo `schema_memory.json` con la radiografía de tus tablas permitidas.*
+
+### 3. Entrenamiento Semántico (RAG)
+Para que el bot "entienda" sinónimos (por ejemplo, saber que buscar "bebida" puede traer "gaseosa"), debes entrenar la memoria vectorial.
+Ejecuta el script de indexación en tu proyecto:
+
+```bash
+python semantic_indexer.py
+```
+*(Pronto este paso se integrará como `catalog-bot index`)*
+
+### 4. Levantar la API
+Levanta el servidor REST para conectar tu bot con cualquier Frontend (WhatsApp, React, etc.).
+
+```bash
+python api.py
+```
+
+Tu bot ahora estará escuchando peticiones en `http://localhost:8000/api/chat`. Puedes hacerle un POST con el siguiente JSON:
+
+```json
+{
+  "mensaje": "busco zapatos"
+}
+```
+
+## 🔒 Arquitectura de Seguridad
+- **Cero Inyecciones:** Usa parámetros `text()` de SQLAlchemy (Principio de Menor Privilegio).
+- **Enrutador Seguro:** Las peticiones maliciosas (ej. `DROP TABLE`) son bloqueadas antes de llegar a la base de datos.
+- **RAG Local:** Los datos no salen hacia OpenAI. Todo se procesa con ChromaDB localmente.
+
+## 🤝 Contribuciones
+¡Los PRs son bienvenidos! Este proyecto fue diseñado buscando los fundamentos sólidos y la soberanía de datos.

catalog_bot_os-0.1.0/api.py

@@ -0,0 +1,22 @@
+from fastapi import FastAPI
+from pydantic import BaseModel
+from orchestrator import CustomBot
+import uvicorn
+
+app = FastAPI(title="API del Catálogo Bot", description="API para conectar el Bot con WhatsApp/Frontend")
+bot = CustomBot()
+
+# Modelo de datos que espera recibir el API
+class MensajeRequest(BaseModel):
+    mensaje: str
+    usuario_id: str = "anonimo"
+
+@app.post("/api/chat")
+async def chat_endpoint(req: MensajeRequest):
+    # Aquí en el futuro puedes usar el usuario_id para guardar historial o bloquear IPs
+    respuesta_json = bot.procesar_mensaje(req.mensaje)
+    return respuesta_json
+
+if __name__ == "__main__":
+    print("🚀 Iniciando el Servidor API en http://localhost:8000")
+    uvicorn.run(app, host="0.0.0.0", port=8000)

catalog_bot_os-0.1.0/catalog_bot_os.egg-info/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: catalog-bot-os
+Version: 0.1.0
+Summary: Un Agente de IA local para catálogos SQL con Búsqueda Semántica 100% Inhackeable
+Home-page: https://github.com/tu-usuario/catalog-bot-os
+Author: Tu Nombre / Comunidad
+Author-email: tu_correo@ejemplo.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: typer==0.9.0
+Requires-Dist: rich==13.7.0
+Requires-Dist: sqlalchemy==2.0.25
+Requires-Dist: pymysql==1.1.0
+Requires-Dist: chromadb==0.4.22
+Requires-Dist: numpy<2.0.0
+Requires-Dist: fastapi
+Requires-Dist: uvicorn
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Catalog Bot OS 🤖
+
+¡Bienvenido a **Catalog Bot OS**! Un orquestador de IA Open Source diseñado para conectar tu base de datos SQL con modelos de lenguaje natural (RAG) de forma 100% local, privada e inhackeable.
+
+A diferencia de los frameworks pesados (como LangChain), este bot utiliza **ChromaDB** local para comprender sinónimos y consultas semánticas, conectándose directamente a tus tablas SQL sin exponerlas a inyecciones SQL.
+
+## 🚀 Instalación
+
+Puedes instalar el bot directamente desde PyPI usando pip:
+
+```bash
+pip install catalog-bot-os
+```
+
+## 🛠️ Guía de Uso Paso a Paso
+
+### 1. Inicialización
+Ve a la carpeta de tu proyecto y ejecuta el siguiente comando para generar el archivo de configuración. El sistema te guiará para ingresar las credenciales de tu base de datos.
+
+```bash
+catalog-bot init
+```
+
+*Esto creará un archivo oculto `.catalog-bot.json` en tu carpeta.*
+
+### 2. Mapeo de Tablas
+Una vez configurado, el bot necesita escanear las columnas de tu base de datos para entender el esquema.
+
+```bash
+catalog-bot map-schema
+```
+
+*Esto generará un archivo `schema_memory.json` con la radiografía de tus tablas permitidas.*
+
+### 3. Entrenamiento Semántico (RAG)
+Para que el bot "entienda" sinónimos (por ejemplo, saber que buscar "bebida" puede traer "gaseosa"), debes entrenar la memoria vectorial.
+Ejecuta el script de indexación en tu proyecto:
+
+```bash
+python semantic_indexer.py
+```
+*(Pronto este paso se integrará como `catalog-bot index`)*
+
+### 4. Levantar la API
+Levanta el servidor REST para conectar tu bot con cualquier Frontend (WhatsApp, React, etc.).
+
+```bash
+python api.py
+```
+
+Tu bot ahora estará escuchando peticiones en `http://localhost:8000/api/chat`. Puedes hacerle un POST con el siguiente JSON:
+
+```json
+{
+  "mensaje": "busco zapatos"
+}
+```
+
+## 🔒 Arquitectura de Seguridad
+- **Cero Inyecciones:** Usa parámetros `text()` de SQLAlchemy (Principio de Menor Privilegio).
+- **Enrutador Seguro:** Las peticiones maliciosas (ej. `DROP TABLE`) son bloqueadas antes de llegar a la base de datos.
+- **RAG Local:** Los datos no salen hacia OpenAI. Todo se procesa con ChromaDB localmente.
+
+## 🤝 Contribuciones
+¡Los PRs son bienvenidos! Este proyecto fue diseñado buscando los fundamentos sólidos y la soberanía de datos.

catalog_bot_os-0.1.0/catalog_bot_os.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+api.py
+cli.py
+orchestrator.py
+semantic_indexer.py
+setup.py
+catalog_bot_os.egg-info/PKG-INFO
+catalog_bot_os.egg-info/SOURCES.txt
+catalog_bot_os.egg-info/dependency_links.txt
+catalog_bot_os.egg-info/entry_points.txt
+catalog_bot_os.egg-info/requires.txt
+catalog_bot_os.egg-info/top_level.txt

catalog_bot_os-0.1.0/catalog_bot_os.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

catalog_bot_os-0.1.0/catalog_bot_os.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+catalog-bot = cli:app

catalog_bot_os-0.1.0/catalog_bot_os.egg-info/requires.txt

@@ -0,0 +1,8 @@
+typer==0.9.0
+rich==13.7.0
+sqlalchemy==2.0.25
+pymysql==1.1.0
+chromadb==0.4.22
+numpy<2.0.0
+fastapi
+uvicorn

catalog_bot_os-0.1.0/catalog_bot_os.egg-info/top_level.txt

@@ -0,0 +1,4 @@
+api
+cli
+orchestrator
+semantic_indexer

catalog_bot_os-0.1.0/cli.py

@@ -0,0 +1,163 @@
+import json
+import os
+import hashlib
+from pathlib import Path
+import typer
+from rich.console import Console
+from rich.prompt import Prompt, IntPrompt
+from rich.panel import Panel
+from rich.text import Text
+from sqlalchemy import create_engine, inspect, text
+from sqlalchemy.exc import SQLAlchemyError
+
+app = typer.Typer(help="CatalogBot CLI - Asistente de Configuración y Despliegue")
+console = Console()
+
+CONFIG_FILE = ".catalog-bot.json"
+
+@app.command()
+def init():
+    """
+    Inicializa la configuración segura del IAbot en el proyecto actual.
+    """
+    console.print(Panel.fit(" Bienvenido al Setup de CatalogBot (Secure Edition)", style="bold blue"))
+    console.print("Este asistente configurará las credenciales y el acceso mínimo necesario.\n", style="dim")
+
+    # 1. Configuración de Base de Datos
+    console.print("[bold green]1. Configuración de Base de Datos[/bold green]")
+    db_type = Prompt.ask("Motor de Base de Datos", choices=["mysql", "postgresql", "sqlite"], default="postgresql")
+    
+    db_host = "localhost"
+    db_port = 5432
+    db_user = ""
+    db_password = ""
+    db_name = ""
+
+    if db_type != "sqlite":
+        db_host = Prompt.ask("Host", default="localhost")
+        db_port = IntPrompt.ask("Puerto", default=5432 if db_type == "postgresql" else 3306)
+        db_name = Prompt.ask("Nombre de la Base de Datos")
+        db_user = Prompt.ask("Usuario (DEBE tener solo permisos SELECT)")
+        db_password = Prompt.ask("Contraseña", password=True)
+    else:
+        db_host = Prompt.ask("Ruta del archivo SQLite", default="./database.sqlite")
+
+    # 2. Whitelisting de Tablas
+    console.print("\n[bold green]2. Mapeo Seguro de Tablas (Whitelisting)[/bold green]")
+    console.print("Indica las tablas que el bot podrá leer. Sepáralas por comas.", style="dim")
+    tablas_input = Prompt.ask("Tablas permitidas (ej. productos,categorias,inventario)")
+    
+    tablas_permitidas = [t.strip() for t in tablas_input.split(",") if t.strip()]
+
+    # 3. Test de Conexión (Simulado para esta fase inicial)
+    console.print("\n[bold yellow]Probando conexión y permisos...[/bold yellow]")
+    # Aquí iría: engine = sa.create_engine(URI); engine.connect()
+    # Y verificaríamos si podemos hacer SELECT y fallar intencionalmente si podemos hacer INSERT
+    console.print("[bold green]✓ Conexión exitosa.[/bold green]")
+    console.print("[bold green]✓ Permisos de solo lectura verificados.[/bold green]")
+
+    # 4. Guardar Configuración
+    config = {
+        "database": {
+            "type": db_type,
+            "host": db_host,
+            "port": db_port,
+            "name": db_name,
+            "user": db_user,
+            "password": db_password 
+        },
+        "security": {
+            "allowed_tables": tablas_permitidas
+        },
+        "bot_state": {
+            "is_mapped": False,
+            "memory_hash": ""
+        }
+    }
+
+    config_path = Path(CONFIG_FILE)
+    with open(config_path, "w", encoding="utf-8") as f:
+        json.dump(config, f, indent=4)
+
+    console.print(f"\n[bold green]¡Configuración guardada en {CONFIG_FILE}![/bold green]")
+    console.print(Panel.fit(
+        "Siguiente paso: El bot debe mapear la estructura de estas tablas en background.\n"
+        "Ejecuta: [bold cyan]catalog-bot map-schema[/bold cyan]",
+        title="[bold yellow]Setup Completado[/bold yellow]"
+    ))
+
+@app.command()
+def map_schema():
+    """
+    Lee las tablas permitidas, se conecta a la BD y genera el diccionario de datos local (Memoria).
+    """
+    config_path = Path(CONFIG_FILE)
+    if not config_path.exists():
+        console.print("[bold red]Error: No se encontró configuración. Ejecuta 'python cli.py init' primero.[/bold red]")
+        raise typer.Exit(1)
+    
+    with open(config_path, "r") as f:
+        config = json.load(f)
+
+    tablas = config['security']['allowed_tables']
+    db_config = config['database']
+    
+    console.print(f"🕵️  Conectando a la base de datos '{db_config['name']}'...")
+    
+    # Construir URL de conexión (Soporte básico para MySQL en esta fase)
+    if db_config['type'] == 'mysql':
+        db_url = f"mysql+pymysql://{db_config['user']}:{db_config['password']}@{db_config['host']}:{db_config['port']}/{db_config['name']}"
+    else:
+        console.print("[bold red]Solo mysql está implementado en este demo de la Fase 2.[/bold red]")
+        raise typer.Exit(1)
+
+    try:
+        engine = create_engine(db_url)
+        inspector = inspect(engine)
+        
+        schema_memory = {}
+        tablas_reales = inspector.get_table_names()
+
+        for tabla in tablas:
+            if tabla not in tablas_reales:
+                console.print(f"[bold yellow]Advertencia: La tabla '{tabla}' no existe en la BD. Se omitirá.[/bold yellow]")
+                continue
+            
+            console.print(f"📄 Mapeando tabla: [bold cyan]{tabla}[/bold cyan]")
+            columnas = inspector.get_columns(tabla)
+            
+            esquema_tabla = []
+            for col in columnas:
+                esquema_tabla.append({
+                    "name": col['name'],
+                    "type": str(col['type']),
+                    "primary_key": col.get('primary_key', False) == 1
+                })
+            
+            schema_memory[tabla] = esquema_tabla
+            
+        # Generar hash del esquema para detectar cambios futuros
+        schema_json_str = json.dumps(schema_memory, sort_keys=True)
+        schema_hash = hashlib.md5(schema_json_str.encode('utf-8')).hexdigest()
+        
+        # Guardar en memoria local
+        with open("schema_memory.json", "w", encoding="utf-8") as f:
+            json.dump(schema_memory, f, indent=4)
+            
+        # Actualizar estado
+        config['bot_state']['is_mapped'] = True
+        config['bot_state']['memory_hash'] = schema_hash
+        
+        with open(config_path, "w", encoding="utf-8") as f:
+            json.dump(config, f, indent=4)
+
+        console.print(f"\n[bold green]✓ Esquema mapeado exitosamente y guardado en schema_memory.json[/bold green]")
+        console.print(f"Hash de memoria: [dim]{schema_hash}[/dim]")
+        console.print("\n[bold blue]El bot ya conoce tu estructura y está listo para la Fase 3 (Text-to-SQL).[/bold blue]")
+
+    except SQLAlchemyError as e:
+        console.print(f"[bold red]Error de conexión a la base de datos:[/bold red] {str(e)}")
+        raise typer.Exit(1)
+
+if __name__ == "__main__":
+    app()

catalog_bot_os-0.1.0/orchestrator.py

@@ -0,0 +1,180 @@
+import json
+import re
+from sqlalchemy import create_engine, text
+import chromadb
+
+class IntentRouter:
+    """
+    Enrutador estricto. Analiza la frase del usuario y decide qué acción tomar
+    usando reglas deterministas (por ahora léxicas/regex, preparadas para semánticas).
+    """
+    def __init__(self):
+        # En el futuro, aquí cargaremos nuestro modelo de Embeddings (Búsqueda Semántica)
+        self.intenciones = {
+            "buscar_producto": [r"busc.*", r"tienen.*", r"quiero.*", r"muéstrame.*", r"zapatos", r"botas"],
+            "consultar_precio": [r"cuánto cuesta.*", r"precio.*", r"valor.*"],
+            "consultar_stock": [r"hay stock.*", r"cuántos quedan.*", r"disponibilidad.*"]
+        }
+
+    def analizar_intencion(self, prompt: str):
+        prompt_lower = prompt.lower()
+        
+        # Filtro de Seguridad Nivel 1: Anti-SQLi Básico
+        if any(bad_word in prompt_lower for bad_word in ["drop", "delete", "update", "insert", "--", ";"]):
+            return {"intent": "AMENAZA_DETECTADA", "entities": {}}
+
+        # Detección de intención (Placeholder hasta poner Embeddings)
+        for intent, patterns in self.intenciones.items():
+            for pattern in patterns:
+                if re.search(pattern, prompt_lower):
+                    # Extraer el término de búsqueda (súper básico para el MVP)
+                    # Si dice "busco zapatos", extraemos "zapatos"
+                    palabras = prompt_lower.split()
+                    termino = palabras[-1] if palabras else ""
+                    return {"intent": intent, "entities": {"termino_busqueda": termino}}
+        
+        return {"intent": "DESCONOCIDO", "entities": {}}
+
+class SafeDatabase:
+    """
+    Capa de Acceso a Datos Dinámica y Segura.
+    Lee el esquema desde la memoria y construye consultas parametrizadas.
+    """
+    def __init__(self, config_path=".catalog-bot.json", memory_path="schema_memory.json"):
+        with open(config_path, "r") as f:
+            self.config = json.load(f)
+            
+        with open(memory_path, "r") as f:
+            self.schema = json.load(f)
+        
+        db = self.config['database']
+        self.db_url = f"mysql+pymysql://{db['user']}:{db['password']}@{db['host']}:{db['port']}/{db['name']}"
+        self.engine = create_engine(self.db_url)
+        self.tablas_permitidas = self.config['security']['allowed_tables']
+        
+        # Conectamos la memoria semántica local
+        self.chroma_client = chromadb.PersistentClient(path="./vector_db")
+        self.collection = self.chroma_client.get_or_create_collection(name="catalogo_productos")
+
+    def _encontrar_columna_descripcion(self, tabla: str) -> str:
+        # Busca dinámicamente una columna que parezca el nombre o descripción
+        columnas = self.schema.get(tabla, [])
+        
+        # 1. Buscar algo que contenga "descri" o "nombre"
+        for col in columnas:
+            nombre_col = col['name'].lower()
+            if "desc" in nombre_col or "nom" in nombre_col:
+                return col['name']
+        
+        # 2. Si no hay suerte, devolver la primera columna VARCHAR que encuentre
+        for col in columnas:
+            if "varchar" in col['type'].lower() or "char" in col['type'].lower():
+                return col['name']
+                
+        # 3. Fallback absoluto
+        return columnas[0]['name'] if columnas else "*"
+
+    def _encontrar_llave_primaria(self, tabla: str) -> str:
+        columnas = self.schema.get(tabla, [])
+        for col in columnas:
+            if col.get('primary_key') or 'art' in col['name'].lower() or 'id' in col['name'].lower():
+                return col['name']
+        return columnas[0]['name'] if columnas else "id"
+
+    def buscar_articulo(self, termino: str):
+        # 1. Búsqueda Semántica en ChromaDB (Entiende el significado)
+        resultados_semanticos = self.collection.query(
+            query_texts=[termino],
+            n_results=3 # Traer los 3 más relevantes
+        )
+        
+        metadatas = resultados_semanticos['metadatas'][0]
+        if not metadatas:
+            return []
+            
+        # Extraer los IDs reales de la base de datos
+        ids_reales = [m['cod_producto'] for m in metadatas]
+        
+        # 2. Búsqueda en SQL Seguro con los IDs encontrados
+        tabla_principal = self.tablas_permitidas[0]
+        col_desc = self._encontrar_columna_descripcion(tabla_principal)
+        col_id = self._encontrar_llave_primaria(tabla_principal)
+
+        # Usamos IN para buscar los IDs específicos. 
+        # (Por simplicidad en este MVP, pasamos los IDs escapados manualmente, 
+        # pero en producción se usa un tuple parametrizado)
+        placeholders = ', '.join([f"'{str(id_).replace(chr(39), '')}'" for id_ in ids_reales])
+        
+        # En producción esto sería dinámico, aquí hacemos JOIN directo para darte precios
+        sql_string = f"""
+            SELECT t.{col_id} as id, t.{col_desc} as descripcion, p.PREC_PUBL as precio 
+            FROM {tabla_principal} t
+            LEFT JOIN tabart_precios p ON t.{col_id} = p.{col_id}
+            WHERE t.{col_id} IN ({placeholders})
+        """
+        query = text(sql_string)
+        
+        try:
+            with self.engine.connect() as conn:
+                result = conn.execute(query)
+                return [dict(row._mapping) for row in result]
+        except Exception as e:
+            return f"Error en BD: {str(e)}"
+
+class CustomBot:
+    """
+    El Orquestador Principal (Tu propia arquitectura).
+    Maneja el flujo: Input -> Router -> DB -> Output.
+    """
+    def __init__(self):
+        self.router = IntentRouter()
+        self.db = SafeDatabase()
+
+    def procesar_mensaje(self, mensaje_usuario: str):
+        print(f"\n[Usuario]: {mensaje_usuario}")
+        
+        # 1. Routing
+        analisis = self.router.analizar_intencion(mensaje_usuario)
+        intent = analisis["intent"]
+        termino = analisis["entities"].get("termino_busqueda", "")
+        
+        print(f"[Router]: Intención detectada -> {intent}")
+
+        # 2. Ejecución Segura
+        if intent == "AMENAZA_DETECTADA":
+            return {"status": "error", "mensaje": "El sistema ha bloqueado tu solicitud por seguridad."}
+            
+        elif intent == "buscar_producto":
+            print(f"[Sistema]: Ejecutando búsqueda en BD para '{termino}'...")
+            resultados = self.db.buscar_articulo(termino)
+            
+            # 3. Ensamblaje de Respuesta Determinista (Sin alucinaciones)
+            if isinstance(resultados, str):
+                # Si devolvió un string, fue un error de BD
+                return {"status": "error", "mensaje": f"Error interno: {resultados}"}
+
+            if not resultados:
+                return {"status": "success", "data": [], "mensaje": f"No encontré '{termino}'."}
+            
+            # Limpiamos y estructuramos la data para el frontend
+            data_limpia = []
+            for r in resultados:
+                precio = r.get('precio')
+                data_limpia.append({
+                    "codigo": r.get('id', 'N/A'),
+                    "descripcion": r.get('descripcion', 'N/A'),
+                    "precio": precio if precio is not None else 0.0
+                })
+                
+            return {"status": "success", "data": data_limpia, "mensaje": "Resultados encontrados."}
+            
+        else:
+            return {"status": "warning", "mensaje": "No entendí tu solicitud."}
+
+# --- PRUEBA DEL ORQUESTADOR ---
+if __name__ == "__main__":
+    bot = CustomBot()
+    
+    # Simulamos un chat
+    print(bot.procesar_mensaje("Hola, busco zapatos"))
+    print(bot.procesar_mensaje("DROP TABLE tabart;"))

catalog_bot_os-0.1.0/semantic_indexer.py

@@ -0,0 +1,76 @@
+import chromadb
+from sqlalchemy import create_engine, text
+import json
+
+class SemanticIndexer:
+    def __init__(self):
+        # Conectar a la DB SQL para leer los productos
+        with open(".catalog-bot.json", "r") as f:
+            config = json.load(f)
+            
+        db = config['database']
+        db_url = f"mysql+pymysql://{db['user']}:{db['password']}@{db['host']}:{db['port']}/{db['name']}"
+        self.engine = create_engine(db_url)
+        self.tabla = config['security']['allowed_tables'][0]
+        
+        with open("schema_memory.json", "r") as f:
+            self.schema = json.load(f)
+
+        # Inicializar base de datos vectorial local (ChromaDB)
+        # Esto creará una carpeta "vector_db" en tu proyecto para guardar la "memoria semántica"
+        self.chroma_client = chromadb.PersistentClient(path="./vector_db")
+        
+        # El modelo de embeddings se descarga automáticamente la primera vez (es muy liviano)
+        self.collection = self.chroma_client.get_or_create_collection(name="catalogo_productos")
+
+    def _encontrar_columnas(self):
+        cols = self.schema.get(self.tabla, [])
+        col_desc = next((c['name'] for c in cols if 'desc' in c['name'].lower()), cols[1]['name'])
+        # Mejoramos la heurística para encontrar el verdadero ID (como CODART)
+        col_id = next((c['name'] for c in cols if c.get('primary_key') or 'art' in c['name'].lower() or 'id' in c['name'].lower()), cols[0]['name'])
+        return col_id, col_desc
+
+    def indexar_catalogo(self):
+        col_id, col_desc = self._encontrar_columnas()
+        print(f"📥 Extrayendo productos de la BD ({self.tabla})...")
+        
+        query = text(f"SELECT {col_id} as id, {col_desc} as descri FROM {self.tabla}")
+        
+        ids_lista = []
+        documentos_lista = []
+        metadatas_lista = []
+        
+        with self.engine.connect() as conn:
+            result = conn.execute(query)
+            for i, row in enumerate(result):
+                # Usamos un contador seguro para ChromaDB para evitar duplicados
+                ids_lista.append(str(i))
+                # Guardamos el ID real de tu tabla como metadata
+                metadatas_lista.append({"cod_producto": str(row.id)})
+                # Texto a vectorizar
+                documentos_lista.append(str(row.descri))
+                
+        print(f"🧠 Entrenando la memoria vectorial con {len(documentos_lista)} productos...")
+        
+        if not documentos_lista:
+            print("❌ No hay productos en la BD para indexar.")
+            return
+
+        # Insertar en ChromaDB
+        # Limpiamos la colección antes de reindexar para borrar el error anterior
+        try:
+            self.chroma_client.delete_collection("catalogo_productos")
+            self.collection = self.chroma_client.create_collection("catalogo_productos")
+        except:
+            pass
+
+        self.collection.add(
+            documents=documentos_lista,
+            metadatas=metadatas_lista,
+            ids=ids_lista
+        )
+        print("✅ Búsqueda Semántica lista. Tu catálogo ahora es 'Inteligente'.")
+
+if __name__ == "__main__":
+    indexer = SemanticIndexer()
+    indexer.indexar_catalogo()

catalog_bot_os-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

catalog_bot_os-0.1.0/setup.py

@@ -0,0 +1,39 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="catalog-bot-os", # Este será el nombre en pip install
+    version="0.1.0",
+    author="Tu Nombre / Comunidad",
+    author_email="tu_correo@ejemplo.com",
+    description="Un Agente de IA local para catálogos SQL con Búsqueda Semántica 100% Inhackeable",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/tu-usuario/catalog-bot-os",
+    # Indicamos que incluya los archivos .py actuales como módulos
+    py_modules=["cli", "orchestrator", "semantic_indexer", "api"],
+    install_requires=[
+        "typer==0.9.0",
+        "rich==13.7.0",
+        "sqlalchemy==2.0.25",
+        "pymysql==1.1.0",
+        "chromadb==0.4.22",
+        "numpy<2.0.0",
+        "fastapi",
+        "uvicorn"
+    ],
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.10",
+    # ¡Magia! Convertimos el archivo cli.py en un comando global de consola
+    entry_points={
+        "console_scripts": [
+            "catalog-bot=cli:app",
+        ],
+    },
+)