init project

README.md

@@ -1,13 +1,99 @@
+# 🧑‍🍳 WAIter: Voice Chatbot for Restaurants
+
+WAIter es un chatbot interactivo con capacidades de voz diseñado para escenarios de restaurantes. Simula un camarero amigable y servicial que puede responder a las preguntas habladas de los clientes en tiempo real, utilizando tecnologías de reconocimiento de voz, modelos de lenguaje avanzados y síntesis de voz natural.
+
+## 🛠️ Stack Tecnológico
+
+- **Procesamiento de Voz**:
+  - 🎙️ [FastRTC](https://fastrtc.org) para streaming de audio en tiempo real
+  - 🔊 [ElevenLabs](https://elevenlabs.io/) para síntesis de voz expresiva (TTS)
+  - 🗣️ [Whisper](https://openai.com/research/whisper) (vía Groq) para reconocimiento de voz
+
+- **Inteligencia Artificial de Lenguaje**:
+  - 💬 [LangChain](https://www.langchain.com/) para orquestación de LLMs
+  - 🔄 [LangGraph](https://github.com/langchain-ai/langgraph) para flujos de trabajo de agentes
+  - 🧠 [Gemini 2.5](https://deepmind.google/technologies/gemini/) (vía OpenRouter) para procesamiento de lenguaje natural
+
+- **Gestión de Datos**:
+  - 🔍 Embeddings vectoriales con HuggingFace (BAAI/bge-m3)
+  - 💾 Datos de menú almacenados en formato Markdown
+  - 🗄️ [Supabase](https://supabase.com/) para almacenamiento y procesamiento de pedidos
+
+- **Interfaz**:
+  - 🧪 [Gradio](https://www.gradio.app/) para la interfaz web interactiva
+
+## 🚀 Características
+
+- **Interacción por voz en tiempo real** con un asistente virtual de camarero
+- **Consulta de información del menú** con respuestas contextuales sobre platos, precios y opciones
+- **Procesamiento de pedidos** con capacidad para enviar órdenes directamente a sistemas de cocina
+- **Flujo conversacional natural** usando LangGraph para orquestación compleja de agentes
+- **Integración de base de conocimientos** con RAG (Retrieval Augmented Generation)
+- **Memoria de conversación multi-turno** para respuestas contextuales
+- **Gestión de pedidos** con almacenamiento en Supabase y sistema de seguimiento
+- **Síntesis de voz expresiva** con ElevenLabs para respuestas naturales y fluidas
+
+## 🚀 Primeros Pasos
+
+1. Clona este repositorio
+2. Instala las dependencias: `pip install -r requirements.txt` (requiere Python 3.10+)
+3. Crea un archivo `.env` con tus claves API:
+   ```
+   OPENROUTER_API_KEY=tu_clave_openrouter
+   OPENROUTER_BASE_URL=https://openrouter.ai/api/v1
+   GROQ_API_KEY=tu_clave_groq
+   ELEVENLABS_API_KEY=tu_clave_elevenlabs
+   HELICONE_API_KEY=tu_clave_helicone_opcional
+   SUPABASE_URL=tu_url_supabase
+   SUPABASE_KEY=tu_clave_supabase
+   ```
+4. Ejecuta la aplicación: `python app.py`
+5. Abre la interfaz de Gradio en tu navegador
+
+## 🗂️ Estructura del Proyecto
+
+- `app.py` - Punto de entrada principal con interfaz Gradio
+- `agent.py` - Implementación del agente LangGraph para asistente de restaurante
+- `model.py` - Gestor para la creación y configuración de modelos de lenguaje
+- `tools.py` - Herramientas personalizadas para consulta de menú y envío de pedidos
+- `supabase_client.py` - Cliente para operaciones con la base de datos Supabase
+- `data/carta.md` - Datos del menú del restaurante en formato Markdown
+- `utils/` - Módulos de utilidad:
+  - `functions.py` - Funciones auxiliares para manejo de mensajes y modelos
+  - `logger.py` - Sistema de registro con colores para depuración
+  - `classes.py` - Clases de datos como `Order` para representar pedidos
+
+## 🧠 Cómo Funciona
+
+1. **Reconocimiento de Voz**: FastRTC captura audio del micrófono del usuario y lo envía a la API Whisper de Groq para transcripción
+2. **Procesamiento de Lenguaje Natural**: El texto transcrito se pasa al agente LangGraph
+3. **Procesamiento RAG**: El agente utiliza búsqueda vectorial para encontrar información relevante del menú
+4. **Herramientas del Agente**: El sistema utiliza herramientas especializadas para:
+   - Búsqueda de información en el menú (vectores)
+   - Envío de pedidos a cocina (integración Supabase)
+5. **Generación de Respuesta**: Gemini 2.5 (a través de OpenRouter) genera una respuesta contextual y útil
+6. **Síntesis de Voz**: ElevenLabs convierte la respuesta de texto a voz natural
+7. **Interfaz Web**: Gradio renderiza la conversación y reproduce la respuesta de audio
+
+## 📦 Requisitos del Sistema
+
+Los requisitos detallados se encuentran en el archivo `requirements.txt`. Las principales dependencias incluyen:
+
+- Python 3.10+
+- gradio >= 4.26.0
+- langchain >= 0.1.0 (con varios componentes adicionales)
+- fastrtc >= 0.6.0
+- elevenlabs >= 0.2.24
+- groq >= 0.4.0
+- supabase >= 2.0.0
+- sentence-transformers >= 2.2.2
+
+## 📝 Licencia
+
+[MIT License](LICENSE)
+
 ---
-title: WAIter
-emoji: 🏢
-colorFrom: indigo
-colorTo: red
-sdk: gradio
-sdk_version: 5.31.0
-app_file: app.py
-pinned: false
-short_description: A conversational assistant with voice capabilities and tools
----
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+🌐 Desarrollado por Roberto - 2024
+
+

agent.py

@@ -0,0 +1,115 @@
+from typing import TypedDict, Annotated, List, Dict, Any
+from langgraph.graph.message import add_messages
+from langchain_core.messages import AnyMessage, SystemMessage
+from langgraph.prebuilt import ToolNode
+from langgraph.graph import START, StateGraph
+from langgraph.prebuilt import tools_condition
+from langchain_openai import ChatOpenAI
+from langchain.tools import Tool
+
+from utils.logger import log_info, log_warn, log_error, log_debug
+
+class RestaurantAgent:
+    def __init__(self, llm: ChatOpenAI, restaurant_name: str, tools: List[Tool]):
+        """
+        Inicializa el agente del restaurante con LangGraph.
+        
+        Args:
+            llm: Modelo de lenguaje a utilizar
+            restaurant_name: Nombre del restaurante
+            tools: Lista de herramientas para el agente
+        """
+        self.restaurant_name = restaurant_name
+        self.tools = tools
+        
+        # Prompt para el asistente
+        self.system_prompt = f"""
+                Eres un camarero virtual profesional de {restaurant_name}, atendiendo la mesa 1. Combinas la calidez y simpatía gaditana con un servicio excelente y eficiente.
+
+                ## Tu personalidad
+                - Profesional pero cercano, con el encanto natural de Cádiz
+                - Confiable, simpático y resolutivo
+                - Transmites seguridad en cada recomendación
+                - Hablas con naturalidad, como si fueras un camarero experimentado
+
+                ## Comunicación (optimizada para TTS)
+                - Frases naturales, claras y conversacionales
+                - Tono directo pero amable, sin rodeos innecesarios
+                - Evita símbolos especiales, comillas o emojis
+                - Respuestas concisas que fluyan bien al ser leídas en voz alta
+
+                ## Protocolo de servicio OBLIGATORIO
+                1. **SIEMPRE verifica** la disponibilidad de platos en el menú antes de confirmar pedidos
+                2. **NUNCA recomiendes** productos sin consultarlos primero en la carta
+                3. **Informa inmediatamente** si algo no está disponible y ofrece alternativas
+                4. **Confirma cada pedido** antes de enviarlo a cocina
+                5. **Despídete cordialmente** tras completar el servicio
+
+                ## Manejo de consultas del menú
+                - Cuando pregunten por opciones disponibles: proporciona un resumen claro y natural
+                - Para platos específicos: verifica existencia, precio e ingredientes principales
+                - Si desconoces algo: sé transparente y consulta la información necesaria
+                - Presenta las opciones de forma atractiva pero honesta
+
+                ## Gestión de pedidos
+                - Confirma cada plato solicitado existe en el menú
+                - Repite el pedido completo antes de enviarlo
+                - Informa el tiempo estimado si es relevante
+                - Mantén un registro mental del estado del pedido
+
+                Recuerda: tu objetivo es brindar una experiencia gastronómica excepcional combinando profesionalidad, eficiencia y ese toque especial gaditano que hace sentir como en casa.
+                """
+
+        # Configurar el LLM con las herramientas
+        self.llm_with_tools = llm.bind_tools(tools=tools)
+        
+        # Construir el grafo
+        self.graph = self._build_graph()
+
+    def _build_graph(self) -> StateGraph:
+        """Construye el grafo de estados del agente."""
+        
+        # Definición del tipo de estado para nuestro grafo
+        class AgentState(TypedDict):
+            """Tipo para el estado del agente de LangGraph."""
+            messages: Annotated[list[AnyMessage], add_messages]
+
+        # Nodo para el asistente que invoca al LLM
+        def assistant(state: AgentState):
+            """Procesa los mensajes usando el LLM y devuelve una respuesta."""
+            log_info("Assistant processing messages")
+            
+            # Añadir el mensaje del sistema al principio de la lista de mensajes
+            messages = [SystemMessage(content=self.system_prompt)] + state["messages"]
+            
+            return {
+                "messages": [self.llm_with_tools.invoke(messages)],
+            }
+
+        # Crear el grafo con una estructura mucho más simple
+        builder = StateGraph(AgentState)
+
+        # Definir nodos: el asistente y el nodo para herramientas
+        builder.add_node("assistant", assistant)
+        builder.add_node("tools", ToolNode(self.tools))
+
+        # Definir bordes con enrutamiento condicional automático
+        builder.add_edge(START, "assistant")
+        builder.add_conditional_edges(
+            "assistant",
+            # Si el último mensaje requiere una herramienta, enrutar a "tools"
+            # De lo contrario, terminar el flujo y devolver la respuesta
+            tools_condition,
+        )
+        builder.add_edge("tools", "assistant")
+
+        # Compilar y retornar el grafo
+        return builder.compile()
+
+    def invoke(self, messages: List[AnyMessage]) -> Dict[str, Any]:
+        """
+        Procesa la consulta del usuario y genera una respuesta usando el grafo LangGraph.
+        """
+        log_info(f"Processing query: {messages}")
+
+        return self.graph.invoke({"messages": messages})

app.py

@@ -0,0 +1,414 @@
+import gradio as gr
+from os import getenv, environ
+from dotenv import load_dotenv
+import os
+from model import ModelManager
+from utils.functions import fetch_openrouter_models
+# Configurar la variable de entorno para evitar advertencias de tokenizers (huggingface opcional)
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+ 
+from groq import AsyncClient 
+from fastrtc import WebRTC, ReplyOnPause, audio_to_bytes, AdditionalOutputs
+import numpy as np
+import asyncio 
+from elevenlabs.client import ElevenLabs
+from elevenlabs import VoiceSettings
+
+from langchain_text_splitters.markdown import MarkdownHeaderTextSplitter
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_core.vectorstores import InMemoryVectorStore
+from langchain_core.messages import HumanMessage, AIMessage
+
+from agent import RestaurantAgent
+# Importar las herramientas
+from tools import create_menu_info_tool, create_send_to_kitchen_tool
+
+from utils.logger import log_info, log_warn, log_error, log_success, log_debug
+
+load_dotenv()
+
+# Constantes
+RESTAURANT = "Bar paco"
+
+# Initialize clients and models to None, will be set during runtime
+groq_client = None
+eleven_client = None
+llm = None
+waiter_agent = None
+
+# region RAG
+md_path = "data/carta.md"
+
+with open(md_path, "r", encoding="utf-8") as file:
+    md_content = file.read()
+
+splitter = MarkdownHeaderTextSplitter(
+    headers_to_split_on=[
+        ("#", "seccion_principal"),
+        ("##", "subseccion"),
+        ("###", "apartado")
+    ], 
+    strip_headers=False)
+splits = splitter.split_text(md_content)
+embeddings = HuggingFaceEmbeddings(model_name="BAAI/bge-m3", model_kwargs = {'device': 'cpu'})
+vector_store = InMemoryVectorStore.from_documents(splits, embeddings)
+
+retriever = vector_store.as_retriever(search_kwargs={"k": 4})
+# endregion
+
+# Initialize tools to None
+guest_info_tool = None
+send_to_kitchen_tool = None
+tools = None
+
+# Function to initialize all components with provided API keys
+def initialize_components(openrouter_key, groq_key, elevenlabs_key, model_name):
+    global groq_client, eleven_client, llm, waiter_agent, guest_info_tool, send_to_kitchen_tool, tools
+    
+    log_info("Initializing components with provided API keys...")
+    
+    # Initialize clients with provided keys
+    if groq_key:
+        groq_client = AsyncClient(api_key=groq_key)
+    
+    if elevenlabs_key:
+        eleven_client = ElevenLabs(api_key=elevenlabs_key)
+    
+    if openrouter_key:
+        # Initialize LLM
+        model_manager = ModelManager(
+            api_key=openrouter_key,
+            api_base=getenv("OPENROUTER_BASE_URL", "https://openrouter.ai/api/v1"),
+            model_name=model_name,
+            helicone_api_key=getenv("HELICONE_API_KEY", "")
+        )
+        llm = model_manager.create_model()
+        
+        # Initialize tools
+        guest_info_tool = create_menu_info_tool(retriever)
+        send_to_kitchen_tool = create_send_to_kitchen_tool(llm=llm)
+        tools = [guest_info_tool, send_to_kitchen_tool]
+        
+        # Initialize the agent
+        waiter_agent = RestaurantAgent(
+            llm=llm,
+            restaurant_name=RESTAURANT,
+            tools=tools
+        )
+        
+        log_success("Components initialized successfully.")
+    else:
+        log_warn("OpenRouter API key is required for LLM initialization.")
+    
+    return {
+        "groq_client": groq_client is not None,
+        "eleven_client": eleven_client is not None,
+        "llm": llm is not None,
+        "agent": waiter_agent is not None
+    }
+
+# region FUNCTIONS
+async def handle_text_input(message, history, openrouter_key, groq_key, elevenlabs_key, model_name):
+    """Handles text input, generates response, updates chat history."""
+    global waiter_agent, llm
+    
+    # Initialize components if needed
+    if waiter_agent is None or llm is None or model_name != getattr(llm, "model_name", ""):
+        status = initialize_components(openrouter_key, groq_key, elevenlabs_key, model_name)
+        if not status["agent"]:
+            return history + [
+                {"role": "user", "content": message},
+                {"role": "assistant", "content": "Error: Could not initialize the agent. Please check your API keys."}
+            ]
+    
+    current_history = history if isinstance(history, list) else []
+    log_info("-" * 20) 
+    log_info(f"Received text input: '{message}', current history: {current_history}")
+
+    try:
+        # 1. Actualizar el historial con el mensaje del usuario
+        user_message = {"role": "user", "content": message}
+        history_with_user = current_history + [user_message]
+
+        # 2. Invocar al agente con la consulta del usuario
+        log_info("Iniciando procesamiento con LangGraph...")
+        
+        # Invocar el agente con el texto de la consulta
+        langchain_messages = []
+        for msg in current_history:
+            if msg["role"] == "user":
+                langchain_messages.append(HumanMessage(content=msg["content"]))
+            elif msg["role"] == "assistant":
+                langchain_messages.append(AIMessage(content=msg["content"]))
+    
+        langchain_messages.append(HumanMessage(content=message))
+
+        graph_result = waiter_agent.invoke(langchain_messages)
+        
+        log_debug(f"Resultado del agente: {graph_result}")
+        
+        messages = graph_result.get("messages", [])
+        assistant_text = ""
+        
+        for msg in reversed(messages):
+            # LangChain puede devolver diferentes clases de mensajes
+            if hasattr(msg, "__class__") and msg.__class__.__name__ == "AIMessage":
+                assistant_text = msg.content
+                break
+        
+        if not assistant_text:
+            log_warn("No se encontró respuesta del asistente en los mensajes.")
+            assistant_text = "Lo siento, no sé cómo responder a eso."
+
+        log_info(f"Assistant text: '{assistant_text}'")
+
+        # 3. Actualizar el historial con el mensaje del asistente
+        assistant_message = {"role": "assistant", "content": assistant_text}
+        final_history = history_with_user + [assistant_message]
+        
+        log_success("Tarea completada con éxito.")
+        return final_history
+
+    except Exception as e:
+        log_error(f"Error in handle_text_input function: {e}")
+        import traceback
+        traceback.print_exc()
+        return current_history + [
+            {"role": "user", "content": message},
+            {"role": "assistant", "content": f"Error: {str(e)}"}
+        ]
+    
+async def response(audio: tuple[int, np.ndarray], history, openrouter_key, groq_key, elevenlabs_key, model_name): 
+    """Handles audio input, generates response, yields UI updates and audio."""
+    global waiter_agent, llm, groq_client, eleven_client
+    
+    # Initialize components if needed
+    if waiter_agent is None or llm is None or groq_client is None or eleven_client is None or model_name != getattr(llm, "model_name", ""):
+        status = initialize_components(openrouter_key, groq_key, elevenlabs_key, model_name)
+        if not status["groq_client"]:
+            yield AdditionalOutputs(history + [{"role": "assistant", "content": "Error: Groq API key is required for audio processing."}])
+            return
+        if not status["eleven_client"]:
+            yield AdditionalOutputs(history + [{"role": "assistant", "content": "Error: ElevenLabs API key is required for audio processing."}])
+            return
+        if not status["agent"]:
+            yield AdditionalOutputs(history + [{"role": "assistant", "content": "Error: Could not initialize the agent. Please check your OpenRouter API key."}])
+            return
+
+    current_history = history if isinstance(history, list) else []
+    log_info("-" * 20)
+    log_info(f"Received audio, current history: {current_history}")
+
+    try:
+        # 1. Transcribir el audio a texto
+        audio_bytes = audio_to_bytes(audio)
+        transcript = await groq_client.audio.transcriptions.create(
+            file=("audio-file.mp3", audio_bytes),
+            model="whisper-large-v3-turbo",
+            response_format="verbose_json",
+        )
+        user_text = transcript.text.strip()
+
+        log_info(f"Transcription: '{user_text}'")
+
+        # 2. Actualizar el historial con el mensaje del usuario
+        user_message = {"role": "user", "content": user_text}
+        history_with_user = current_history + [user_message]
+
+        log_info(f"Yielding user message update to UI: {history_with_user}")
+        yield AdditionalOutputs(history_with_user)
+        await asyncio.sleep(0.04) # Permite que la UI se actualice antes de continuar
+
+        # 4. Invocar al agente con la consulta del usuario
+        log_info("Iniciando procesamiento con LangGraph...")
+        
+        langchain_messages = []
+        for msg in current_history:
+            if msg["role"] == "user":
+                langchain_messages.append(HumanMessage(content=msg["content"]))
+            elif msg["role"] == "assistant":
+                langchain_messages.append(AIMessage(content=msg["content"]))
+
+        langchain_messages.append(HumanMessage(content=user_text))
+
+        graph_result = waiter_agent.invoke(langchain_messages)
+        
+        log_debug(f"Resultado del agente: {graph_result}")
+        
+        # Extraer la respuesta del último mensaje del asistente
+        messages = graph_result.get("messages", [])
+        assistant_text = ""
+        
+        # Buscar el último mensaje del asistente
+        for msg in reversed(messages):
+            if hasattr(msg, "__class__") and msg.__class__.__name__ == "AIMessage":
+                assistant_text = msg.content
+                break
+        
+        if not assistant_text:
+            log_warn("No se encontró respuesta del asistente en los mensajes.")
+            assistant_text = "Lo siento, no sé cómo responder a eso."
+
+        log_info(f"Assistant text: '{assistant_text}'")
+
+        # 5. Actualizar el historial con el mensaje del asistente
+        assistant_message = {"role": "assistant", "content": assistant_text}
+        final_history = history_with_user + [assistant_message]
+
+        # 6. Generar la respuesta de voz
+        log_info("Generating TTS...")
+        TARGET_SAMPLE_RATE = 24000 # <<< --- Tasa de muestreo deseada
+        tts_stream_generator = eleven_client.text_to_speech.convert(
+                text=assistant_text,
+                voice_id="Nh2zY9kknu6z4pZy6FhD",
+                model_id="eleven_flash_v2_5",
+                output_format="pcm_24000",
+                voice_settings=VoiceSettings(
+                    stability=0.0,
+                    similarity_boost=1.0, 
+                    style=0.0,
+                    use_speaker_boost=True,
+                    speed=1.1,
+                )
+            )
+        
+        # --- Procesar los chunks a medida que llegan ---
+        log_info("Receiving and processing TTS audio chunks...")
+        audio_chunks = []
+        total_bytes = 0
+
+        for chunk in tts_stream_generator:
+            total_bytes += len(chunk)
+            
+            # Convertir chunk actual de bytes PCM (int16) a float32 normalizado
+            if chunk:
+                audio_int16 = np.frombuffer(chunk, dtype=np.int16)
+                audio_float32 = audio_int16.astype(np.float32) / 32768.0
+                audio_float32 = np.clip(audio_float32, -1.0, 1.0)  # Asegurar rango
+                audio_chunks.append(audio_float32)
+
+        log_info(f"Received {total_bytes} bytes of TTS audio in total.")
+
+        # Concatenar todos los chunks procesados
+        if audio_chunks:
+            final_audio = np.concatenate(audio_chunks)
+            log_info(f"Processed {len(final_audio)} audio samples.")
+        else:
+            log_warn("Warning: TTS returned empty audio stream.")
+            final_audio = np.array([], dtype=np.float32)
+ 
+        # Crear la tupla final
+        tts_output_tuple = (TARGET_SAMPLE_RATE, final_audio)
+    
+        log_debug(f"TTS output: {tts_output_tuple}")   
+        log_success("Tarea completada con éxito.")
+        yield tts_output_tuple
+        yield AdditionalOutputs(final_history) 
+    
+    except Exception as e:
+        log_error(f"Error in response function: {e}")
+        import traceback
+        traceback.print_exc()
+      
+        yield np.array([]).astype(np.int16).tobytes()
+        yield AdditionalOutputs(current_history + [{"role": "assistant", "content": f"Error: {str(e)}"}])
+
+def load_model_ids():
+    # Use asyncio to run the async function
+    try:
+        models = asyncio.run(fetch_openrouter_models())
+        # Extract model IDs and names
+        model_ids = [model["id"] for model in models]
+        return model_ids
+    except Exception as e:
+        log_error(f"Error loading model IDs: {e}")
+        return ["openai/gpt-4o-mini", "google/gemini-2.5-flash-preview", "anthropic/claude-3-5-sonnet"]  # Fallback models
+# endregion
+
+with gr.Blocks() as demo:
+    gr.Markdown("# WAIter Chatbot")
+    with gr.Row():
+        text_openrouter_api_key = gr.Textbox(
+            label="OpenRouter API Key (required)",
+            placeholder="Enter your OpenRouter API key",
+            value=getenv("OPENROUTER_API_KEY") or "",
+            type="password",
+        )
+        text_groq_api_key = gr.Textbox(
+            label="Groq API Key (required for audio)",
+            placeholder="Enter your Groq API key",
+            value=getenv("GROQ_API_KEY") or "",
+            type="password",
+        )
+        text_elevenlabs_api_key = gr.Textbox(
+            label="Elevenlabs API Key (required for audio)",
+            placeholder="Enter your Elevenlabs API key",
+            value=getenv("ELEVENLABS_API_KEY") or "",
+            type="password",
+        )
+        
+    chatbot = gr.Chatbot(
+        label="Agent",
+        type="messages",
+        value=[],
+        avatar_images=(
+            None, # User avatar
+            "https://em-content.zobj.net/source/twitter/376/hugging-face_1f917.png", # Assistant
+        ),
+    )
+
+    with gr.Row():
+        model_dropdown = gr.Dropdown(
+            label="Select Model",
+            choices=load_model_ids(),
+            value=getenv("MODEL") or "openai/gpt-4o-mini",
+            interactive=True
+        )
+
+        text_input = gr.Textbox(
+            label="Type your message",
+            placeholder="Type here and press Enter...",
+            show_label=True,
+        )
+
+        audio = WebRTC(
+            label="Speak Here",
+            mode="send-receive", 
+            modality="audio",
+        )
+    
+    text_input.submit(
+        fn=handle_text_input,
+        inputs=[
+            text_input, 
+            chatbot, 
+            text_openrouter_api_key, 
+            text_groq_api_key, 
+            text_elevenlabs_api_key,
+            model_dropdown
+        ],
+        outputs=[chatbot],
+        api_name="submit_text"
+    ).then(
+        fn=lambda: "",  # Limpiar el campo de texto
+        outputs=[text_input]
+    )
+
+    # Se encarga de manejar la entrada de audio
+    audio.stream(
+        fn=ReplyOnPause(
+            response, 
+            can_interrupt=True,
+        ), 
+        inputs=[audio, chatbot, text_openrouter_api_key, text_groq_api_key, text_elevenlabs_api_key, model_dropdown], 
+        outputs=[audio], 
+    )
+
+    # Actualiza el historial de la conversación
+    audio.on_additional_outputs(
+        fn=lambda history_update: history_update, # Envia el historial actualizado 
+        outputs=[chatbot], # Actualiza el chatbot 
+    )
+
+if __name__ == "__main__":
+    demo.launch()

data/carta.md

@@ -0,0 +1,247 @@
+# BAR PACO
+*Tradición y Sabor en el Corazón de la Ciudad*
+
+📍 Calle Ficticia, 123, Madrid | 🕛 Abierto todos los días: 12:00 - 00:00
+---
+
+## 🐖 LAS CHACINAS DE CARDESA
+*Selección de los mejores ibéricos y quesos, cortados al momento.*
+
+- **Bandeja de Jamón Ibérico de Bellota D.O. Extremadura** – **24,00 €**  
+  *(100% Raza Ibérica, curación mínima 36 meses)*  
+  (½ ración **14,00 €**)
+- **Bandeja de Caña de Lomo Ibérico de Bellota D.O. Guijuelo** – **24,00 €**  
+  *(Embuchado natural, sabor intenso y delicado)*  
+  (½ ración **12,50 €**)
+- **Tabla de Ibéricos de Bellota Variados** – **24,00 €**  
+  *(Jamón, lomo, chorizo y salchichón ibérico de bellota)*  
+  (½ ración **14,00 €**)
+- **Plato de Cecina de León I.G.P. "Reserva"** – **20,00 €**  
+  *(Curada al aire de la montaña leonesa, con un toque ahumado)*  
+  (½ ración **12,00 €**)
+- **Plato de Queso Curado de Oveja Artesano** – **16,00 €**  
+  *(Selección de quesos manchegos y zamoranos con D.O.)*  
+  (Porción individual **9,00 €**)
+- **Mojama de Atún Extra de Barbate con Almendras Marconas** – **18,00 €**
+
+> *Nuestras chacinas se sirven con picos camperos y regañás. Para una experiencia superior, recomendamos nuestro Pan de Cristal con Tomate Rallado y AOVE Premium – **4,00 €***
+
+---
+
+## 🍽️ PARA COMPARTIR (Tapas y Raciones)
+
+**DE LA HUERTA Y CLÁSICOS:**
+- **Ensalada Bar Paco** – **13,50 €**  
+  *(Mezclum de lechugas, tomate, cebolla tierna, atún, huevo duro, espárragos y aceitunas)*
+- **Tomates Rosados de Temporada con Ventresca de Bonito del Norte** – **15,90 €**
+- **Tomate Rosado con Berberechos Gallegos al Natural** – **15,90 €**
+- **Tomate Rosado con Burrata Fresca, Pesto Genovés Casero y Rúcula** – **17,00 €**
+- **Tomate "Huevo de Toro" Aliñado (en temporada)** – **11,00 €**  
+  *(Con ajo, comino, orégano y AOVE)*
+- **Parrillada de Verduras de Temporada a la Brasa** – **16,90 €**  
+  *(Espárragos, calabacín, berenjena, pimientos, cebolla, champiñones... con salsa romesco casera)*
+- **Flores de Alcachofas Frescas a la Plancha con Lascas de Jamón Ibérico** – **17,90 €**
+- **Alcachofas Confitadas a la Andaluza con Reducción de Pedro Ximénez** – **16,90 €**
+- **Ensaladilla Rusa "Estilo Piera"** – **8,90 €**  
+  *(Nuestra receta tradicional con ingredientes frescos y mayonesa casera)*
+- **Patatas Bravas "Estilo Paco"** - **8,50 €**  
+  *(Con nuestra salsa brava secreta y alioli suave)*
+- **Morcilla de Burgos con Piñones Frita y Pimientos de Padrón** – **8,00 €**
+- **Torreznos de Soria Crujientes D.O.** – **11,90 €**
+- **Croquetas Cremosas Caseras de Jamón Ibérico de Bellota (8 uds.)** – **12,00 €**
+- **Croquetas Caseras de Boletus Edulis y Trufa (8 uds.)** – **13,00 €**
+- **Degustación de Croquetas (4 Jamón, 4 Boletus)** – **12,50 €**
+- **Huevos Estrellados con Jamón Ibérico y Patatas Paja** – **15,50 €**
+- **Huevos Estrellados con Gulas del Norte Salteadas y Gambas al Ajillo** – **15,90 €**
+- **Huevos Estrellados con Chistorra de Navarra y Pimientos del Piquillo** – **14,90 €**
+
+**DEL MAR:**
+- **Anchoas del Cantábrico "00" en Salazón (8 lomos)** – **18,90 €**  
+  *(Sobre lecho de tomate rallado y pan tostado)*
+- **Boquerones de Málaga Frescos Fritos a la Andaluza** – **10,90 €**
+- **Pulpo a la Brasa sobre Parmentier de Patata y Pimentón de la Vera** – **22,90 €**
+- **Pulpo Frito con Alioli de Ajo Negro** - **22,90 €**
+- **Chipirones Encebollados a Fuego Lento con Tinta y Arroz Blanco** – **18,90 €**
+- **Chipirones Frescos Fritos a la Andaluza con Limón** – **18,90 €**  
+  (½ ración **10,50 €**)
+- **Calamar de Potera Fresco a la Plancha con Ajo y Perejil** – **20,50 €**
+- **Calamar de Potera Fresco Frito a la Andaluza** – **19,00 €**  
+  (½ ración **12,00 €**)
+- **Mejillones de las Rías Baixas al Vapor o a la Marinera** – **12,90 €**
+- **Gamba Blanca de Huelva Cocida, a la Plancha o al Ajillo (200g)** – **21,00 €**
+- **Zamburiñas Frescas Gratinadas con Jamón Ibérico y Cebolla Caramelizada (6 uds.)** – **19,90 €**
+- **Almejas Finas a la Marinera o al Ajillo** – **21,50 €**
+
+---
+
+## 🍲 LOS PUCHEROS DE LA ABUELA
+*Platos de cuchara con sabor a tradición. Disponibles según temporada.*
+
+- **Fabada Asturiana Tradicional con su Compango Casero** – **15,50 €**
+- **Sopa Castellana con Huevo Escalfado y Virutas de Jamón** – **9,50 €**
+- **Lentejas Estofadas con Chorizo y Verduras de la Huerta** – **12,00 €**
+- **Callos a la Madrileña (receta de la casa)** – **14,50 €**
+- **Potaje de Garbanzos con Espinacas y Bacalao (Viernes de Cuaresma y temporada)** - **13,50 €**
+
+> *En verano, no te pierdas nuestro **Salmorejo Cordobés Casero** con virutas de jamón y huevo duro – **7,50 €** y nuestro **Gazpacho Andaluz Tradicional** - **7,00 €***
+
+---
+
+## 🥩 NUESTRAS CARNES A LA BRASA Y GUISADAS
+*Selección de las mejores carnes nacionales, maduradas y cocinadas en nuestra parrilla de carbón de encina o guisadas con mimo.*
+*(Todas nuestras carnes a la brasa se sirven con patatas fritas caseras y pimientos de Padrón)*
+
+- **Entrecot de Vaca Madurada (350g aprox.)** – **23,00 €**  
+  *(Maduración dry-aged mínima 30 días)*
+- **Chuletón de Vaca Madurada (1,300 kg aprox., para 2 personas)** – **49,00 €**  
+  *(Maduración dry-aged mínima 45 días, trinchado en mesa)*
+- **Solomillo de Ternera Charra a la Parrilla (250g aprox.)** – **25,00 €**
+- **Chuletillas de Cordero Lechal de Aranda D.O.** – **24,50 €**
+- **Presa Ibérica de Bellota a la Parrilla** – **20,50 €**  
+  *(Con mojo picón casero)*
+- **Secreto Ibérico de Bellota a la Parrilla** – **19,50 €**
+  *(Con chimichurri artesanal)*
+- **Parrillada de Cordero Lechal Deshuesado** – **19,50 €**
+- **Rabo de Toro Estofado al Vino Tinto (Disponible según mercado, consultar)** – **25,00 €**
+- **Mollejas de Cordero Lechal Salteadas al Ajillo o Empanadas** – **15,90 €**
+- **Steak Tartar de Solomillo de Ternera (Preparado al momento a su gusto)** – **24,50 €**
+- **Cochinillo Confitado y Crujiente (Cochifrito)** – **18,90 €**
+- **Huevos Fritos de Corral con Jamón Ibérico de Bellota y Patatas Fritas Caseras** – **16,90 €**
+- **Carrilleras de Cerdo Ibérico Estofadas al Pedro Ximénez con Puré de Boniato** – **18,50 €**
+
+---
+
+## 🔥 NUESTROS ASADOS TRADICIONALES (POR ENCARGO)
+*Asados en horno de leña. Se recomienda encargar con 24h de antelación.*
+
+- **Cordero Lechal Asado Entero (para 4-6 personas)** – Consultar precio
+  *(Cuarto delantero o trasero – **48,50 €**)*
+- **Paletilla de Cordero Lechal Asada Individual** – **24,90 €**
+- **¼ de Cabrito Lechal Asado (para 2-3 personas)** – **48,50 €**
+- **Cochinillo Asado Entero (para 4-6 personas)** – Consultar precio
+- **Ración de Cochinillo Tostón Asado** – **24,90 €**
+
+> *Todos los asados se acompañan de patatas panaderas y ensalada mixta.*
+
+---
+
+## 🐟 PESCADOS FRESCOS DEL DÍA
+*Directos de lonja, preparados a la brasa, al horno o según la tradición. Pregunte por nuestras sugerencias fuera de carta.*
+
+- **Rodaballo Salvaje a la Parrilla con Bilbaína (pieza entera, para 2 pers.)** – S.P.M. (Según Precio de Mercado)
+- **Bacalao Confitado a Baja Temperatura sobre Vizcaína o al Pil Pil** – **23,00 €**
+- **Merluza de Pincho del Cantábrico a la Gallega, a la Romana o a la Plancha** – **19,90 €**
+- **Lomo de Atún Rojo de Almadraba a la Plancha con Salsa de Soja y Sésamo** – **24,90 €**
+- **Tartar de Atún Rojo de Almadraba con Aguacate y Mango** – **24,90 €**
+- **Fritura Malagueña Variada (Boquerones, calamares, salmonetes, adobo...)** – **22,50 €**
+  (Para 2 personas)
+- **Dados de Bacalao Fresco Fritos con Pimientos Asados** – **19,90 €**
+- **Rodaballo Salvaje al Horno con Patatas Panaderas y Verduras (mín. 2-4 personas, pieza entera)** – S.P.M.
+- **Lubina Salvaje a la Sal o a la Espalda (mín. 2 personas, pieza entera)** – **44,00 €**
+- **Pargo Salvaje al Horno con Limón y Hierbas Provenzales (pieza entera)** – S.P.M.
+- **Lenguado Fresco a la Plancha "Meunière"** – S.P.M.
+
+---
+
+## 🍚 ARROCES Y PAELLAS (MÍNIMO 2 PERSONAS)
+*Nuestros arroces se elaboran al momento con ingredientes frescos. Tiempo de preparación aprox. 30-40 min. Precio por persona (P/P).*
+
+- **Arroz a Banda Tradicional** – **17,90 €** P/P  
+  *(Con delicioso fumet de pescado de roca y marisco, servido con alioli casero)*
+- **Arroz del Senyoret (Marisco Pelado)** – **19,50 €** P/P
+- **Arroz Negro con Sepia de Potera y Chipirones** – **18,50 €** P/P
+- **Paella Valenciana Auténtica (Pollo de corral, conejo, judía verde y garrofó)** – **18,90 €** P/P  
+  *(Por encargo preferiblemente)*
+- **Paella de Marisco Fresco (Gambas, cigalas, mejillones, almejas...)** – **21,90 €** P/P
+- **Arroz con Secreto Ibérico, Setas de Temporada y Espárragos Trigueros** – **17,90 €** P/P
+- **Fideuá de Gandía con Marisco y Alioli** - **18,90 €** P/P
+
+**ARROCES CALDOSOS Y MELOSOS:**
+- **Arroz Caldoso de Bogavante Azul** – **23,90 €** P/P
+- **Arroz Meloso de Carabineros y Nécoras** – **26,90 €** P/P
+- **Arroz Meloso con Verduras de Temporada y Alcachofas** – **16,50 €** P/P (Opción Vegetariana)
+
+---
+
+## 🍰 POSTRES CASEROS
+*El broche de oro perfecto para tu comida.*
+
+- **Tarta de Queso Cremosa Casera al Horno con Frutos Rojos** – **7,50 €**
+- **Flan de Huevo Casero con Nata Montada y Caramelo** – **6,50 €**
+- **Arroz con Leche Asturiano Tradicional Caramelizado** – **7,00 €**
+- **Tarta Fina de Manzana Reineta con Helado de Vainilla Bourbon** – **7,50 €**
+- **Coulant de Chocolate Negro Belga (70%) con Corazón Fluido y Helado de Mandarina** – **7,50 €**
+- **Milhojas de Hojaldre Crujiente con Crema Pastelera y Nata** – **7,50 €**
+- **Torrijas Caseras de Leche y Canela con Helado de Leche Merengada (en temporada)** – **7,90 €**
+- **Selección de Helados Artesanos (dos bolas a elegir)** – **6,50 €**  
+  *(Vainilla, Chocolate, Fresa, Limón, Turrón, Leche Merengada)*
+- **Sorbete de Limón al Cava o Mandarina** – **6,00 €**
+- **Fruta Fresca de Temporada Preparada** – **5,50 €**
+
+---
+
+## 🥤 BEBIDAS
+
+**AGUAS Y REFRESCOS:**
+- Agua Mineral Natural (50cl) – **2,00 €**
+- Agua con Gas (25cl) – **2,50 €**
+- Refrescos (Coca-cola, Cola, Fanta Naranja, Limón, Tónica, etc.) – **2,80 €**
+- Zumos Naturales (Naranja recién exprimido) – **4,00 €**
+- Zumos Embotellados (Melocotón, Piña, Tomate) – **2,80 €**
+
+**CERVEZAS:**
+- Caña (Mahou Clásica / Tostada 0,0) – **2,50 €**
+- Doble (Mahou Clásica / Tostada 0,0) – **3,20 €**
+- Tercio Nacional (Mahou Cinco Estrellas, Alhambra Reserva 1925, Estrella Galicia) – **3,50 €**
+- Cerveza Artesanal Local (Consultar selección) – desde **4,50 €**
+- Clara con Limón o Casera – **3,00 €**
+- Cerveza Sin Alcohol / Sin Gluten – **3,50 €**
+
+**VINOS (Consultar nuestra Carta de Vinos completa):**
+- **Vino de la Casa (Tinto, Blanco, Rosado D.O. La Mancha)**
+  - Copa – **2,80 €**
+  - Botella – **14,00 €**
+- **Generosos de Jerez y Montilla-Moriles:**
+  - Fino, Manzanilla – Copa **2,50 €**
+  - Amontillado, Oloroso, Palo Cortado – Copa desde **3,50 €**
+  - Pedro Ximénez – Copa **4,00 €**
+- *Amplia selección de D.O. Rioja, Ribera del Duero, Rueda, Rías Baixas, Toro, Priorat, Cava, Champagne, etc.*
+
+**VERMUTS Y APERITIVOS:**
+- Vermut de Grifo Casero (Rojo o Blanco) – **3,50 €**
+- Selección de Vermuts Premium (Yzaguirre, Lustau, Miró...) – desde **4,50 €**
+- Aperol Spritz, Campari Soda – **7,00 €**
+
+**CAFÉS E INFUSIONES:**
+- Café Solo, Cortado, Americano – **1,80 €**
+- Café con Leche, Capuccino – **2,20 €**
+- Carajillo (Brandy, Ron, Whisky, Anís) – **3,00 €**
+- Infusiones Variadas (Té, Manzanilla, Poleo-Menta) – **2,00 €**
+
+**LICORES Y COMBINADOS:**
+- Chupito de Licor de Hierbas, Orujo, Pacharán – **3,00 €**
+- Combinados Nacionales (Ron, Ginebra, Whisky) – **7,00 €**
+- Combinados Premium (Consultar) – desde **9,00 €**
+
+---
+
+## 📝 INFORMACIÓN ADICIONAL
+
+- **MENÚ DEL DÍA:** Disponible de Lunes a Viernes (excepto festivos).  
+  *Incluye primero, segundo, pan, bebida y postre o café. Consultar pizarra.* – **14,50 €**
+- **SUGERENCIAS DEL CHEF:** Pregunte por nuestras especialidades fuera de carta y productos de temporada.
+- **PAN Y APERITIVO:** Servicio de pan artesano y aperitivo de la casa por persona – **1,80 €** (Opcional, comuníquelo si no lo desea).
+- **ALÉRGENOS:** Este establecimiento dispone de información detallada sobre la presencia de alérgenos en nuestros productos. Por favor, consulte a nuestro personal.
+- **RESERVAS:** Se recomienda reservar, especialmente fines de semana y festivos.
+- **WIFI:** Disponemos de Wi-Fi gratuito para clientes.
+- **IVA INCLUIDO** en todos los precios.
+
+---
+
+📞 **Reservas:** 91 579 10 18
+📧 **Email:** [email protected]
+🌐 **Web:** [www.elpacorestaurante.com](http://www.elpacorestaurante.com)
+📷 **Instagram:** @barpacorestaurante
+🐦 **Twitter:** @barpacorestaurante
+
+*¡Gracias por su visita y buen provecho!*

model.py

@@ -0,0 +1,77 @@
+from os import getenv
+from typing import Optional
+from langchain_openai import ChatOpenAI
+
+class ModelManager:
+    """
+    A class to manage the creation and configuration of language model instances.
+    Handles API keys and provides fallbacks if environment variables are not found.
+    """
+    
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        api_base: Optional[str] = None,
+        model_name: str = "google/gemini-2.5-flash-preview",
+        helicone_api_key: Optional[str] = None,
+    ):
+        """
+        Initialize the ModelManager with the specified parameters.
+        
+        Args:
+            api_key: The API key for the language model service. If None, will try to get from environment.
+            api_base: The base URL for the language model service. If None, will try to get from environment.
+            model_name: The name of the model to use.
+            helicone_api_key: The Helicone API key for logging. If None, will try to get from environment.
+        """
+        
+        self.api_key = api_key
+        if not self.api_key:
+            print("Warning: No API key found.")
+            
+        self.api_base = api_base 
+        if not self.api_base:
+            print("Warning: No API base URL found.")
+            
+        self.helicone_api_key = helicone_api_key
+        
+        self.model_name = model_name
+        
+    def create_model(self, **kwargs) -> Optional[ChatOpenAI]:
+        """
+        Create and return a configured language model instance.
+        
+        Args:
+            **kwargs: Additional keyword arguments to pass to the model constructor.
+            
+        Returns:
+            A configured ChatOpenAI instance, or None if required parameters are missing.
+        """
+        # Check if required parameters are available
+        if not self.api_key or not self.api_base:
+            print("Error: Cannot create model. Missing required API key or base URL.")
+            return None
+            
+        # Prepare model kwargs
+        model_kwargs = kwargs.get("model_kwargs", {})
+        
+        # Add Helicone headers if available
+        if self.helicone_api_key:
+            extra_headers = model_kwargs.get("extra_headers", {})
+            extra_headers["Helicone-Auth"] = f"Bearer {self.helicone_api_key}"
+            model_kwargs["extra_headers"] = extra_headers
+            
+        # Update kwargs with new model_kwargs
+        kwargs["model_kwargs"] = model_kwargs
+            
+        # Create and return the model
+        try:
+            return ChatOpenAI(
+                openai_api_key=self.api_key,
+                openai_api_base=self.api_base,
+                model_name=self.model_name,
+                **kwargs
+            )
+        except Exception as e:
+            print(f"Error creating model: {str(e)}")
+            return None

requirements.txt

@@ -0,0 +1,29 @@
+# WAIter dependencies
+
+# Core
+gradio>=4.26.0
+langchain>=0.1.0
+langchain-openai>=0.0.5
+langchain-huggingface>=0.0.2
+langchain-text-splitters>=0.0.1
+langchain-core>=0.1.17
+
+# Language models
+openai>=1.10.0
+groq>=0.4.0
+
+# Vector store
+sentence-transformers>=2.2.2
+
+# Audio processing
+fastrtc>=0.6.0
+elevenlabs>=0.2.24
+numpy>=1.24.0
+
+# Database
+supabase>=2.0.0
+
+# Utilities
+python-dotenv>=1.0.0
+qrcode>=7.4.2
+pillow>=10.0.0

supabase_client.py

@@ -0,0 +1,99 @@
+from supabase import create_client
+import os
+from dotenv import load_dotenv
+from typing import Dict, List, Any, Optional
+import json
+import logging
+
+from utils.classes import Order
+# Configurar logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class SupabaseOrderManager:
+    def __init__(self, url: Optional[str] = None, key: Optional[str] = None):
+        """
+        Inicializa el gestor de órdenes con Supabase.
+        
+        Args:
+            url: URL de Supabase (opcional, por defecto usa variables de entorno)
+            key: Clave de API de Supabase (opcional, por defecto usa variables de entorno)
+        """
+        # Cargar variables de entorno
+        load_dotenv()
+        
+        # Usar parámetros proporcionados o variables de entorno
+        self.supabase_url = url or os.getenv("SUPABASE_URL")
+        self.supabase_key = key or os.getenv("SUPABASE_KEY")
+        
+        if not self.supabase_url or not self.supabase_key:
+            raise ValueError("SUPABASE_URL y SUPABASE_KEY deben estar definidos como variables de entorno o proporcionados como parámetros")
+        
+        # Inicializar cliente
+        self.supabase = create_client(self.supabase_url, self.supabase_key)
+        logger.info("Cliente Supabase inicializado correctamente")
+    
+    async def send_order(self, order: Order) -> Dict[str, Any]:
+        """
+        Envía una orden a Supabase.
+        
+        Args:
+            order: Objeto Order del sistema del restaurante
+            
+        Returns:
+            Diccionario con el resultado de la operación
+        """
+        try:
+            # Convertir el objeto Order a un diccionario
+            order_dict = order.to_dict()
+            
+            # 1. Insertar la orden principal
+            order_data = {
+                "order_id": order_dict["order_id"],
+                "table_number": str(order_dict["table_number"]),
+                "special_instructions": order_dict["special_instructions"],
+                "status": "pending"
+            }
+            
+            # Realizar la inserción de la orden
+            order_response = self.supabase.table("orders").insert(order_data).execute()
+            
+            if not order_response.data:
+                raise Exception("Error al insertar orden en Supabase")
+            
+            # Obtener el ID de la orden insertada
+            db_order_id = order_response.data[0]["id"]
+            
+            # 2. Insertar los elementos de la orden
+            items_to_insert = []
+            for item in order_dict["items"]:
+                items_to_insert.append({
+                    "order_id": db_order_id,
+                    "name": item["name"],
+                    "quantity": item.get("quantity", 1),
+                    "variations": item.get("variations", "")
+                })
+            
+            # Realizar la inserción de los elementos
+            if items_to_insert:
+                items_response = self.supabase.table("order_items").insert(items_to_insert).execute()
+                
+                if not items_response.data:
+                    # Si falla la inserción de items, eliminamos la orden para mantener consistencia
+                    self.supabase.table("orders").delete().eq("id", db_order_id).execute()
+                    raise Exception("Error al insertar elementos de la orden en Supabase")
+            
+            logger.info(f"Orden {order_dict['order_id']} enviada correctamente a Supabase")
+            return {
+                "success": True,
+                "order_id": order_dict["order_id"],
+                "database_id": db_order_id
+            }
+            
+        except Exception as e:
+            logger.error(f"Error al enviar orden a Supabase: {str(e)}")
+            return {
+                "success": False,
+                "error": str(e)
+            }
+    

tools.py

@@ -0,0 +1,226 @@
+from langchain.tools import Tool
+from langchain_core.vectorstores import VectorStoreRetriever
+from typing import Optional
+
+from utils.logger import log_info, log_warn, log_error, log_debug
+import json
+from langchain_core.messages import HumanMessage, SystemMessage
+from langchain_openai import ChatOpenAI
+from utils.classes import Order
+
+from supabase_client import SupabaseOrderManager
+import asyncio
+
+try:
+    supabase = SupabaseOrderManager()
+except Exception as e:
+    log_error(f"Error al inicializar el cliente de Supabase: {e}")
+    supabase = None
+
+
+def create_menu_info_tool(retriever: VectorStoreRetriever) -> Tool:
+    """
+    Crea una herramienta para extraer información relevante del menú del restaurante.
+    
+    Args:
+        retriever: Un retriever configurado para buscar en la base de conocimiento del menú
+        
+    Returns:
+        Una herramienta de LangChain para consultar información del menú
+    """
+    def extract_text(query: str) -> str:
+        """Extrae texto relevante del menú basado en la consulta."""
+        results = retriever.invoke(query)
+        log_info("ENTRADA DE EXTRACCIÓN DE TEXTO")
+        
+        result_texts = []
+        if results:
+            log_info("\n=== Fragmentos de documento utilizados para la respuesta ===")
+            for i, result in enumerate(results):
+                log_info(f"Fragmento {i+1}: {result.page_content[:100]}...")
+                
+                # Comprobar si tiene score (algunos retrievers no incluyen este atributo)
+                if hasattr(result, 'score'):
+                    log_info(f"Score: {result.score}")
+                    
+                result_texts.append(result.page_content)
+            log_info("=========================================================\n")
+            
+            # Unir los resultados relevantes
+            return "\n\n".join(result_texts)
+        else:
+            return "Lo siento, no tengo información sobre eso."
+    
+    return Tool(
+    name="guest_info_tool",
+    description="""Herramienta para consultar información detallada del menú del restaurante.
+        Úsala cuando necesites:
+        - Buscar platos específicos y verificar su disponibilidad
+        - Consultar precios exactos de productos
+        - Obtener información sobre ingredientes, alérgenos o composición de platos
+        - Explorar secciones del menú (entrantes, principales, postres, bebidas, etc.)
+        - Verificar la existencia de productos antes de recomendarlos
+        - Responder preguntas específicas sobre la carta del restaurante
+        
+        Esta herramienta accede al contenido completo del menú para proporcionar información precisa y actualizada.""",
+    func=extract_text,
+)
+
+def create_send_to_kitchen_tool(llm: ChatOpenAI) -> Tool:
+    """
+    Crea una herramienta para enviar pedidos a la cocina.
+    
+    Args:
+        llm: Un modelo de lenguaje para analizar la conversación
+        
+    Returns:
+        Una herramienta de LangChain para enviar pedidos a la cocina
+    """
+    def extract_order_from_summary(conversation_summary: str) -> Order:
+        """
+        Usa un LLM para extraer detalles del pedido a partir de un resumen de la conversación.
+        
+        Args:
+            conversation_summary: Resumen de la conversación entre cliente y camarero
+            
+        Returns:
+            Objeto Order con los detalles del pedido extraído
+        """
+        # Crear mensaje para el LLM
+        messages = [
+            SystemMessage(content="""
+            Eres un asistente especializado en extraer información de pedidos de restaurante.
+            Analiza el siguiente resumen de conversación entre un cliente y un camarero.
+            Extrae SOLO los elementos del pedido (platos, bebidas, etc.), cantidades, y cualquier instrucción especial.
+            Devuelve los resultados en formato JSON entre las etiquetas <order> </order> estrictamente con esta estructura:
+            {
+                "table_number": número_de_mesa (entero o "desconocida" si no se especifica),
+                "items": [
+                    {
+                        "name": "nombre_del_plato",
+                        "quantity": cantidad (entero, por defecto 1),
+                        "variations": "variaciones o personalizaciones"
+                    },
+                    ...
+                ],
+                "special_instructions": "instrucciones especiales generales"
+            }
+            No incluyas ninguna otra información o explicación, SOLO el JSON entre las etiquetas.
+            """),
+            HumanMessage(content=f"Resumen de la conversación: {conversation_summary}")
+        ]
+        
+        # Invocar el LLM para obtener el análisis del pedido
+        response = llm.invoke(messages)
+        response_text = response.content
+        
+        # Extraer el JSON de la respuesta usando las etiquetas <order></order>
+        try:
+            # Buscar contenido entre etiquetas <order> y </order>
+            import re
+            order_pattern = re.compile(r'<order>(.*?)</order>', re.DOTALL)
+            order_match = order_pattern.search(response_text)
+            
+            if order_match:
+                # Extraer el contenido JSON de las etiquetas
+                json_str = order_match.group(1).strip()
+                order_data = json.loads(json_str)
+                
+                # Crear objeto Order con los datos extraídos
+                return Order(
+                    items=order_data.get("items", []),
+                    special_instructions=order_data.get("special_instructions", ""),
+                    table_number=order_data.get("table_number", "desconocida")
+                )
+            else:
+                # Si no hay etiquetas, reportar error
+                log_error("No se encontraron etiquetas <order> en la respuesta del LLM")
+                # Devolver un objeto Order vacío con un flag de error
+                empty_order = Order(table_number="desconocida")
+                empty_order.error = "NO_TAGS_FOUND"
+                return empty_order
+                    
+        except json.JSONDecodeError as e:
+            log_error(f"Error al parsear JSON de la respuesta del LLM: {e}")
+            log_debug(f"Respuesta problemática: {response_text}")
+            empty_order = Order(table_number="desconocida")
+            empty_order.error = "JSON_PARSE_ERROR"
+            return empty_order
+        except Exception as e:
+            log_error(f"Error inesperado al procesar la respuesta: {e}")
+            log_debug(f"Respuesta completa: {response_text}")
+            empty_order = Order(table_number="desconocida")
+            empty_order.error = "UNKNOWN_ERROR"
+            return empty_order
+    
+    def send_to_kitchen(conversation_summary: str) -> str:
+        """
+        Procesa el resumen de la conversación para extraer el pedido y enviarlo a la cocina.
+        
+        Args:
+            conversation_summary: Resumen de la conversación cliente-camarero
+            
+        Returns:
+            Mensaje de confirmación
+        """
+        try:
+            log_info(f"Procesando resumen para enviar pedido a cocina...")
+            log_debug(f"Resumen recibido: {conversation_summary}")
+            
+            # Extraer el pedido a partir del resumen
+            order = extract_order_from_summary(conversation_summary)
+            
+            # Verificar si hay un error en el procesamiento
+            if hasattr(order, 'error') and order.error:
+                if order.error == "NO_TAGS_FOUND":
+                    log_error("No se encontraron las etiquetas <order> en la respuesta del LLM")
+                    return "Lo siento, ha ocurrido un problema al procesar su pedido. Por favor, inténtelo de nuevo."
+                elif order.error == "JSON_PARSE_ERROR":
+                    log_error("Error al analizar el JSON en las etiquetas <order>")
+                    return "Ha ocurrido un error técnico al procesar su pedido. ¿Podría repetirlo de otra forma?"
+                else:
+                    log_error(f"Error desconocido: {order.error}")
+                    return "Lo siento, algo salió mal al procesar su pedido. Por favor, inténtelo de nuevo."
+            
+            # Verificar si hay elementos en el pedido
+            if not order.items:
+                log_warn("No se identificaron artículos en el pedido")
+                return "No se pudo identificar ningún artículo en el pedido. ¿Podría repetir su pedido, por favor?"
+            
+            # Simular envío a la cocina
+            order_dict = order.to_dict()
+            log_info(f"ENVIANDO PEDIDO A COCINA: {json.dumps(order_dict, indent=2, ensure_ascii=False)}")
+            
+            # Aquí iría la integración real con el sistema de la cocina
+            # Por ejemplo, enviar a una API, base de datos, etc.
+            async def async_send_and_get_result(order):
+                return await supabase.send_order(order)
+            
+            res = asyncio.run(async_send_and_get_result(order))
+            if res.get("success"):
+                log_info(f"Pedido enviado correctamente a la cocina: {res['order_id']}")
+                return f"Su pedido ha sido enviado a la cocina. ID de pedido: {res['order_id']}"
+            else:
+                log_error(f"Error al enviar el pedido a la cocina: {res.get('error', 'Desconocido')}")
+                return "Lo siento, hubo un problema al enviar su pedido a la cocina. ¿Podría intentarlo de nuevo?"
+
+        except Exception as e:
+            log_error(f"Error al procesar pedido: {e}")
+            log_debug(f"Error detallado: {str(e)}")
+            import traceback
+            log_debug(traceback.format_exc())
+            return "Lo siento, hubo un problema al procesar su pedido. ¿Podría intentarlo de nuevo?"
+    
+    # Retornar la herramienta configurada con la función send_to_kitchen
+    return Tool(
+        name="send_to_kitchen_tool",
+        description="""
+        Envía el pedido completo a la cocina. Usa esta herramienta SOLAMENTE cuando el cliente haya terminado de hacer su pedido 
+        completo y esté listo para enviarlo.
+        
+        Esta herramienta espera recibir un RESUMEN de la conversación que describe los elementos del pedido.
+        No envíes la conversación completa, solo un resumen claro de lo que el cliente ha pedido, la mesa, 
+        y cualquier instrucción especial relevante.
+        """,
+        func=send_to_kitchen,
+    )

utils/classes.py

@@ -0,0 +1,35 @@
+from typing import Dict, Any
+from datetime import datetime
+
+class Order:
+    """Representa un pedido de comida para la cocina."""
+    def __init__(self, items=None, special_instructions=None, table_number=None):
+        self.items = items or []
+        self.special_instructions = special_instructions or ""
+        self.table_number = table_number
+        self.timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        self.order_id = f"ORD-{datetime.now().strftime('%Y%m%d%H%M%S')}"
+        self.error = None  # Campo para indicar si hay un error
+    
+    def add_item(self, item: Dict[str, Any]):
+        """Añade un elemento al pedido."""
+        self.items.append(item)
+    
+    def to_dict(self):
+        """Convierte el pedido a un diccionario."""
+        return {
+            "order_id": self.order_id,
+            "timestamp": self.timestamp,
+            "table_number": self.table_number,
+            "items": self.items,
+            "special_instructions": self.special_instructions,
+            "error": self.error
+        }
+    
+    def __str__(self):
+        """Representación en texto del pedido."""
+        if self.error:
+            return f"Pedido con error: {self.error}"
+            
+        items_str = ", ".join([f"{item.get('quantity', 1)}x {item.get('name', 'item')}" for item in self.items])
+        return f"Pedido {self.order_id} - Mesa {self.table_number}: {items_str}"

utils/functions.py

@@ -0,0 +1,60 @@
+import aiohttp
+from typing import List, Dict, Any
+
+async def fetch_openrouter_models() -> List[Dict[str, Any]]:
+    """
+    Asynchronously fetch available models from the OpenRouter API.
+        
+    Returns:
+        A list of dictionaries containing model information.
+        Empty list if the request fails.
+    """
+    # Define the endpoint
+    models_endpoint = "https://openrouter.ai/api/v1/models"
+    
+    try:
+        # Prepare headers
+        headers = {
+            "Content-Type": "application/json"
+        }
+        
+        # Make the async request
+        async with aiohttp.ClientSession() as session:
+            async with session.get(models_endpoint, headers=headers) as response:
+                # Check if request was successful
+                if response.status == 200:
+                    data = await response.json()
+                    return data.get("data", [])
+                else:
+                    error_text = await response.text()
+                    print(f"Error fetching models: HTTP {response.status} - {error_text}")
+                    return []
+            
+    except Exception as e:
+        print(f"Error fetching models: {str(e)}")
+        return []
+    
+
+async def list_openrouter_models_summary() -> List[Dict[str, Any]]:
+    """
+    Asynchronously returns a simplified list of available OpenRouter models with key information.
+           
+    Returns:
+        A list of dictionaries with model ID, name, context length, and pricing.
+    """
+    models = await fetch_openrouter_models()
+    
+    summary = []
+    for model in models:
+        summary.append({
+            "id": model.get("id"),
+            "name": model.get("name"),
+            "context_length": model.get("context_length"),
+            "modality": model.get("architecture", {}).get("modality"),
+            "pricing": {
+                "prompt": model.get("pricing", {}).get("prompt"),
+                "completion": model.get("pricing", {}).get("completion")
+            }
+        })
+        
+    return summary

utils/logger.py

@@ -0,0 +1,36 @@
+"""
+Módulo de logging para la aplicación wAIter.
+Proporciona funciones para imprimir logs en colores según su importancia.
+"""
+
+class Colors:
+    """Constantes de colores ANSI para los logs en terminal."""
+    RESET = "\033[0m"
+    RED = "\033[91m"
+    GREEN = "\033[92m"
+    YELLOW = "\033[93m"
+    BLUE = "\033[94m"
+    MAGENTA = "\033[95m"
+    CYAN = "\033[96m"
+    WHITE = "\033[97m"
+    BOLD = "\033[1m"
+
+def log_info(msg):
+    """Log información general (azul cian)."""
+    print(f"{Colors.CYAN}[INFO] {msg}{Colors.RESET}")
+    
+def log_warn(msg):
+    """Log advertencias (amarillo)."""
+    print(f"{Colors.YELLOW}[WARN] {msg}{Colors.RESET}")
+    
+def log_error(msg):
+    """Log errores (rojo)."""
+    print(f"{Colors.RED}[ERROR] {msg}{Colors.RESET}")
+    
+def log_success(msg):
+    """Log éxitos/completados (verde)."""
+    print(f"{Colors.GREEN}[SUCCESS] {msg}{Colors.RESET}")
+    
+def log_debug(msg):
+    """Log depuración detallada (magenta)."""
+    print(f"{Colors.MAGENTA}[DEBUG] {msg}{Colors.RESET}")