¿Tu Qwen3.5 en LM Studio responde “no tengo acceso en tiempo real” y no genera archivos como Excel, PDF o Word? Esta es la guía completa con todo lo que necesitas saber: desde configurar búsquedas web hasta crear agentes especializados para cotizaciones, diseño, código y generación de archivos. Sin necesidad de ser programador.

1. Arquitectura: por qué el chat de LM Studio no es suficiente

El error más común es intentar usar el chat de LM Studio esperando que funcionen herramientas como DuckDuckGo o generación de archivos. Aquí está la diferencia clave:

Flujo correcto:

LM Studio: Cargas el modelo (Qwen3.5, Mixtral, etc.) > Start Server > Lo minimizas (no uses su chat para herramientas).

Open WebUI: Aquí creas todo (Tools, Pipes, Agentes) y chateas. Ves los resultados de las herramientas, archivos generados y agentes en acción.

2. Requisitos validados en 2026

Antes de empezar, verifica que tu equipo cumpla con estos requisitos para evitar errores:

Nota: Si tu hardware no cumple con los requisitos para Mixtral 8x7B, usa Qwen3.5-7B o versiones más ligeras como Qwen3.5-4B.

3. Instalación: LM Studio + Open WebUI

3.1 LM Studio como servidor (backend)

LM Studio es el motor que ejecuta el modelo. No lo uses para chatear si necesitas herramientas externas.

1. Descarga e instala LM Studio 0.4.12 o superior.
2. En la pestaña Discover, busca Qwen3.5-7B-Instruct Q4_K_M (o el modelo que prefieras) y haz clic en Download.
3. Espera a que termine la descarga. Los modelos pueden pesar varios GB.
4. Ve a la pestaña Developer y haz clic en Start Server.
5. Activa las opciones:
   • CORS (para permitir conexiones desde Open WebUI).
   • Apply Model Template (para compatibilidad con herramientas).
6. En My Models, selecciona tu modelo y activa:
   • Enable Tool Use (para permitir el uso de herramientas externas).
   • Function Calling (si está disponible).
7. Verifica que aparezca el mensaje: Server running on port 1234.
8. Minimiza LM Studio. No uses su chat para herramientas externas. Su función es solo ejecutar el modelo como servidor.

3.2 Open WebUI como interfaz de control (frontend)

Open WebUI es la interfaz donde configurarás herramientas, agentes y chatearás con el modelo.

1. Abre una terminal (PowerShell en Windows, Terminal en macOS/Linux).
2. Instala Open WebUI con:pip install open-webui --upgrade

   Nota: Usa –upgrade para asegurarte de tener la última versión.

3. Inicia el servidor de Open WebUI:open-webui serve

   Nota: Si el puerto 3000 está ocupado, usa open-webui serve --port 8080.

4. Abre tu navegador y ve a http://localhost:3000.
5. La primera vez, te pedirá crear una cuenta de administrador (es local, no requiere internet).
6. Conecta Open WebUI a LM Studio:
   1. Ve a Settings > Connections > OpenAI API.
   2. Configura:
      • URL: http://localhost:1234/v1
      • API Key: lm-studio (puede ser cualquier texto, LM Studio no lo valida).
   3. Haz clic en Save y luego en Verify Connection. Debe aparecer un mensaje de éxito.

Nota: Si ves errores de dependencias (como conflictos con click o open-interpreter), revisa la sección “Depuración: los 5 errores que todos cometen” más abajo.

4. Solución de errores comunes de instalación

4.1 Error: Incompatibilidad entre Open WebUI 0.3.x y Click 8.2.0+ en Windows

Causa: Open WebUI 0.3.8 usa flags que Click 8.2+ ya no permite en parámetros no booleanos. Esto genera el error: TypeError: Secondary flag is not valid for non-boolean flag.

Soluciones:

Opción 1: Degradar Click (solución rápida)

1. Abre PowerShell como administrador.
2. Ejecuta:pip install "click==8.1.7" --force-reinstall
3. Prueba el servidor:open-webui serve

Nota: Click 8.1.7 es la última versión compatible con Open WebUI 0.3.x.

Opción 2: Actualizar Open WebUI (recomendada)

Las versiones 0.4.0+ ya han resuelto este problema:

1. Desinstala la versión actual:pip uninstall open-webui
2. Instala la última versión:pip install open-webui --upgrade
3. Verifica la versión:open-webui --version

   Debe ser 0.4.0 o superior.

4. Inicia el servidor:open-webui serve

Si sigue fallando:

• Instala las dependencias que faltan:pip install langchain-community duckduckgo-search
• Si el puerto 3000 está ocupado, usa otro:open-webui serve --port 8080
• Si hay error de Pydantic:pip install "pydantic==2.5.3"

Alternativa sin conflictos: Usar Docker

Si prefieres evitar problemas de dependencias, usa Docker para ejecutar Open WebUI de manera aislada:

1. Instala Docker desde Docker Desktop.
2. Ejecuta:docker run -d -p 3000:8080 -v open-webui:/app/backend/data --name open-webui ghcr.io/open-webui/open-webui:main
3. Accede a Open WebUI en: http://localhost:3000.

Ventaja: Docker aísla todas las dependencias, evitando conflictos con otras aplicaciones de Python.

4.2 Error: Conflictos de dependencias con open-interpreter

Si ves errores como pip’s dependency resolver does not currently take into account all the packages that are installed, es porque hay conflictos entre las versiones de los paquetes instalados.

Causa: open-interpreter está pidiendo versiones antiguas de paquetes como anthropic, psutil, starlette y tiktoken, mientras que Open WebUI o LM Studio han instalado versiones más recientes.

Soluciones:

Opción 1: Ignorar el error (si no usas open-interpreter)

Si instalaste open-interpreter solo para probar y no lo usas con Qwen3.5, puedes ignorar el mensaje de error. No afecta el funcionamiento de Open WebUI ni LM Studio.

Nota: El mensaje ERROR: pip’s dependency resolver es solo un aviso. Mientras open-webui serve arranque correctamente, todo está bien.

Opción 2: Actualizar open-interpreter

Las versiones nuevas de open-interpreter ya han resuelto estos conflictos:

pip install open-interpreter --upgrade

Nota: Si aún hay conflictos con starlette, usa la Opción 3.

Opción 3: Usar entornos virtuales (recomendado)

La mejor práctica para evitar conflictos es usar entornos virtuales de Python:

1. Abre una terminal y navega a tu directorio de trabajo:cd C:\Users\tu_usuario (Windows) o cd ~/ (macOS/Linux).
2. Crea un entorno virtual para Open WebUI:python -m venv openwebui-env
3. Activa el entorno virtual:
   • Windows: .\openwebui-env\Scripts\activate
   • macOS/Linux: source openwebui-env/bin/activate
4. Instala Open WebUI y sus dependencias en el entorno virtual:pip install open-webui langchain-community duckduckgo-search
5. Inicia Open WebUI:open-webui serve

Ventaja: open-interpreter puede quedarse en tu entorno global de Python con sus versiones antiguas, mientras que Open WebUI tiene sus propias dependencias sin conflictos.

4. Tools: dale superpoderes a cualquier modelo

Los Tools son funciones en Python que tu modelo de IA puede usar para realizar tareas específicas, como búsquedas web, generación de archivos o consultas a APIs. A continuación, te mostramos cómo instalar y configurar los Tools esenciales.

Primero, instala las dependencias necesarias:

pip install langchain-community duckduckgo-search requests pandas openpyxl fpdf python-docx pillow

En Open WebUI, ve a Workspace > Tools > + New Tool y crea los siguientes 4 Tools:

Tool 1: DuckDuckGo Search – para noticias y búsquedas web

Nombre: duckduckgo_web_search

Descripción: Búsqueda web sin API key para obtener información actualizada.

Código:

"""
title: DuckDuckGo Search
description: Búsqueda web sin API key para obtener información actualizada.
requirements: langchain-community
"""

from langchain_community.utilities import DuckDuckGoSearchAPIWrapper

class Tools:
    def __init__(self):
        self.search = DuckDuckGoSearchAPIWrapper(region='wt-wt', time='d', max_results=5)

    def web_search(self, query: str) -> str:
        """Busca en internet información actualizada."""
        try:
            return self.search.run(query)
        except Exception as e:
            return f"Error: {str(e)}"

Requisitos: langchain-community

Nota: Este Tool usa DuckDuckGo para buscar información en internet. Es útil para noticias, precios, clima y cualquier dato que necesite actualización.

Tool 2: Currency Rates – para tipos de cambio en tiempo real

Nombre: currency_rates

Descripción: Obtiene el tipo de cambio actual de USD a MXN, BRL y EUR usando una API especializada.

Código:

"""
title: Currency Rates
description: Tipo de cambio USD real desde API.
requirements: requests
"""

import requests

class Tools:
    async def get_exchange_rates(self) -> str:
        """Obtiene USD a MXN, BRL, EUR en tiempo real."""
        try:
            r = requests.get("https://api.exchangerate-api.com/v4/latest/USD", timeout=10)
            if r.status_code == 200:
                d = r.json()["rates"]
                return f"USD Hoy:\n- 1 USD = {d['MXN']:.2f} MXN\n- 1 USD = {d['BRL']:.2f} BRL\n- 1 USD = {d['EUR']:.2f} EUR\nFuente: exchangerate-api.com"
            else:
                return f"Error API: Status {r.status_code}"
        except Exception as e:
            return f"Error obteniendo tipo de cambio: {str(e)}"

Requisitos: requests

Nota: Este Tool usa una API especializada en divisas, por lo que los datos son más precisos que los de DuckDuckGo para tipos de cambio.

Tool 3: Excel Generator – para cotizaciones y datos tabulares

Nombre: excel_generator

Descripción: Crea archivos Excel (.xlsx) desde datos en formato CSV.

Código:

"""
title: Excel Generator
description: Crea archivos .xlsx desde CSV.
requirements: pandas openpyxl
"""

import pandas as pd
import io

class Tools:
    async def create_excel(self, data: str, filename: str = "datos.xlsx") -> str:
        """Crea Excel. data debe ser CSV: Col1,Col2\nVal1,Val2"""
        try:
            df = pd.read_csv(io.StringIO(data))
            df.to_excel(filename, index=False)
            return f"Excel creado: {filename}. Descárgalo desde el enlace arriba."
        except Exception as e:
            return f"Error: {str(e)}. Usa formato CSV correcto (ej: Nombre,Edad\nJuan,25\nAna,30)."

Requisitos: pandas openpyxl

Nota: Para usar este Tool, debes proporcionar los datos en formato CSV (valores separados por comas). Ejemplo:

Producto,Cantidad,Precio\nLaptop,5,850\nMonitor,10,200

Tool 4: Document + Image Generator – para PDF, Word y PNG

Nombre: document_generator

Descripción: Crea archivos PDF, Word y imágenes desde texto.

Código:

"""
title: Document Generator
description: Crea PDF, DOCX y PNG desde texto.
requirements: fpdf python-docx pillow
"""

from fpdf import FPDF
from docx import Document
from PIL import Image, ImageDraw
import textwrap

class Tools:
    async def create_pdf(self, content: str, filename: str = "documento.pdf") -> str:
        """Crea PDF desde texto."""
        try:
            pdf = FPDF()
            pdf.add_page()
            pdf.set_font("Arial", size=12)
            for line in content.split('\n'):
                try:
                    pdf.cell(200, 10, txt=line.encode('latin-1', 'replace').decode('latin-1'), ln=True)
                except:
                    pdf.cell(200, 10, txt=line, ln=True)
            pdf.output(filename)
            return f"PDF creado: {filename}. Descárgalo desde el enlace arriba."
        except Exception as e:
            return f"Error al crear PDF: {str(e)}"

    async def create_word(self, content: str, filename: str = "documento.docx") -> str:
        """Crea Word desde texto."""
        try:
            doc = Document()
            for line in content.split('\n'):
                doc.add_paragraph(line)
            doc.save(filename)
            return f"Word creado: {filename}. Descárgalo desde el enlace arriba."
        except Exception as e:
            return f"Error al crear Word: {str(e)}"

    async def create_image(self, text: str, filename: str = "imagen.png") -> str:
        """Crea imagen 1080x1080 con texto centrado."""
        try:
            img = Image.new('RGB', (1080, 1080), color=(20, 20, 30))
            draw = ImageDraw.Draw(img)
            y = 540 - len(textwrap.wrap(text, 20)) * 30
            for line in textwrap.wrap(text, 20):
                draw.text((540, y), line, fill=(255, 255, 255), anchor="mm")
                y += 60
            img.save(filename)
            return f"Imagen creada: {filename}. Descárgala desde el enlace arriba."
        except Exception as e:
            return f"Error al crear imagen: {str(e)}"

Requisitos: fpdf python-docx pillow

Nota: Este Tool permite generar archivos PDF, Word y imágenes con texto. Útil para crear informes, cotizaciones o diseños simples.

5. Agentes especializados: plantillas para copiar y pegar

Un agente es una combinación de un modelo base + un System Prompt + Tools específicos. Puedes crearlos en Workspace > Models > New Model.

Todos los agentes usan como base qwen/qwen3.5-9b o mistralai/Mixtral-8x7B-Instruct-v0.1 (si tu hardware lo permite).

Agente 1: Contador de cotizaciones

Model ID: cotizaciones-agent

Nombre: Agente Cotizaciones MXN/BRL

Modelo base: qwen/qwen3.5-9b o mistralai/Mixtral-8x7B-Instruct-v0.1

Tools activados: Currency Rates, Excel Generator, Document Generator

System Prompt:

Eres contador senior especializado en México y Brasil. Tu trabajo es generar cotizaciones profesionales y precisas.

REGLAS ESTRICTAS:
1. Para CUALQUIER precio en USD, usa la herramienta get_exchange_rates PRIMERO.
2. Calcula:
   - Subtotal MXN = USD * TipoCambioMXN
   - Subtotal BRL = USD * TipoCambioBRL
   - IVA (16% para México) = Subtotal MXN * 0.16
   - Total MXN = Subtotal MXN + IVA
3. Formato CSV para Excel:
   Cliente,Producto,Cantidad,PrecioUSD,PrecioMXN,PrecioBRL,SubtotalMXN,IVA,TotalMXN
4. Al final, ejecuta create_excel con el CSV y create_pdf con un resumen ejecutivo.
5. Fecha hoy: 2026-05-05. Nunca digas "no tengo acceso". Tienes herramientas para obtener datos reales.

Ejemplo de salida:
---
[Datos obtenidos]
USD Hoy:
- 1 USD = 17.23 MXN
- 1 USD = 5.08 BRL

[Cotización generada]
Cliente,Producto,Cantidad,PrecioUSD,PrecioMXN,PrecioBRL,SubtotalMXN,IVA,TotalMXN
Cliente XYZ,Laptop,5,850,14645.5,4318,73227.5,11716.4,84943.9

Excel creado: cotizacion_cliente_xyz.xlsx
PDF creado: resumen_cotizacion_cliente_xyz.pdf
---

Prueba: Selecciona el agente y escribe:

Cotiza para Cliente XYZ: 5 laptops a 850 USD, 10 monitores a 200 USD

Agente 2: Diseñador gráfico

Model ID: diseno-agent

Nombre: Agente Diseño Social

Modelo base: qwen/qwen3.5-9b o mistralai/Mixtral-8x7B-Instruct-v0.1

Tools activados: Document Generator

System Prompt:

Eres director de arte y especialista en diseño para redes sociales. Tu trabajo es crear copies y piezas visuales impactantes.

FLUJO DE TRABAJO:
1. Pregunta al usuario: cual es el público objetivo, tono (formal, casual, humorístico), colores principales y objetivo de la pieza (ventas, engagement, branding).
2. Genera un copy corto y llamativo (máximo 10 palabras).
3. Llama a create_image con el copy generado. Usa formato 1080x1080 (cuadrado para redes).
4. Para propuestas completas, usa create_pdf con:
   - Portada con título y fecha.
   - Sección "Concepto": Explica la idea en 3 líneas.
   - Sección "Posts": 3 ideas de posts con sus respectivos copies e imágenes generadas.
5. Nunca entregues solo texto. Siempre genera al menos un archivo visual (imagen o PDF).

Ejemplo de salida:
---
[Concepto]
Público: Jóvenes 18-25 años
Tono: Humorístico
Colores: Azul y blanco
Objetivo: Engagement en Instagram

[Copy generado]
"Domina el futuro con un clic"

Imagen creada: post_futuro.png

[Propuesta completa]
PDF creado: propuesta_redes_sociales.pdf
---

Agente 3: Programador Python + Datos

Model ID: code-agent

Nombre: Agente Python Datos

Modelo base: qwen/qwen3.5-9b o mistralai/Mixtral-8x7B-Instruct-v0.1

Tools activados: Excel Generator

System Prompt:

Eres analista de datos senior especializado en Python. Tu trabajo es limpiar, analizar y visualizar datos de manera profesional.

REGLAS:
1. Si el usuario proporciona datos, da 3 insights clave primero (ej: "El producto A tiene un 20% más de ventas que el B").
2. Limpia los datos (elimina duplicados, corrige formatos) y genera un CSV limpio.
3. Llama a create_excel con los datos limpios.
4. Para cálculos complejos, muestra la fórmula usada (ej: "Promedio = Suma(valores) / N").
5. Formato de salida:
   - Insights (3 puntos clave).
   - Tabla de datos limpios.
   - Archivo Excel generado.

Ejemplo de salida:
---
[Insights]
1. El producto Laptop tiene las ventas más altas (5 unidades a 850 USD).
2. El monitor es el producto con mayor cantidad vendida (10 unidades).
3. El total de ventas en USD es 8,500.

[Datos limpios]
Producto,Cantidad,PrecioUSD
Laptop,5,850
Monitor,10,200

Excel creado: datos_limpios.xlsx
---

Agente 4: General con internet forzado

Model ID: internet-agent

Nombre: Qwen con Internet

Modelo base: qwen/qwen3.5-9b o mistralai/Mixtral-8x7B-Instruct-v0.1

Tools activados: DuckDuckGo Search

System Prompt:

You are Qwen, an advanced AI assistant created by Alibaba Cloud. You have access to the web_search tool for real-time information.

MANDATORY RULES:
1. For ANY question about current events, news, weather, prices, sports, people, or information after September 2024, you MUST call web_search FIRST.
2. Use 2-3 different search queries if the first result is not enough.
3. NEVER say "I cannot access real-time data" or "my knowledge cutoff is 2024". You have web_search - use it.
4. Base your answer ONLY on the web_search results. Cite the sources explicitly.
5. If web_search fails or returns no results, say "No encontré resultados para tu consulta" - do NOT claim lack of access.
6. Today is 2026-05-05. Always use this date as reference for current information.

Example format:
---
[Web Search Results]
- Source 1: [Relevant information from search]
- Source 2: [Additional relevant information]

[Answer]
Based on the search results, [your answer here]. Sources: [list sources].
---

6. Pipes: cuando el modelo se niega a usar Tools

Los Pipes son funciones que se ejecutan antes de que el modelo procese tu mensaje. Son útiles para forzar comportamientos, como buscar en internet automáticamente o modificar el prompt antes de que el modelo lo vea.

Qwen3.5 a veces dice “no tengo acceso en tiempo real” aunque tenga DuckDuckGo activo. Esto ocurre porque el modelo tiene un sesgo de entrenamiento que lo lleva a negarse a buscar. La solución es usar un Pipe que fuerce la búsqueda antes de que el modelo responda.

Pipe 1: MoE Router – para ruteo inteligente de preguntas

Nombre: moe_router

Descripción: Rutea preguntas al experto correcto y fuerza búsqueda web cuando sea necesario.

Código:

"""
title: MoE Router Pipe
description: Rutea preguntas al experto correcto y fuerza búsqueda web.
requirements: langchain-community
"""

from langchain_community.utilities import DuckDuckGoSearchAPIWrapper

class Pipe:
    def __init__(self):
        self.search = DuckDuckGoSearchAPIWrapper(region='mx-es', time='d', max_results=5)
        self.keywords = {
            "finanzas": ["dolar", "peso", "real", "bitcoin", "bolsa", "usd", "cotiza", "precio", "iva", "factura"],
            "noticias": ["noticia", "hoy", "pasó", "actualidad", "última", "últimas", "novedades"],
            "clima": ["clima", "temperatura", "lluvia", "pronóstico", "tiempo"],
            "deportes": ["partido", "resultado", "fútbol", "cancha", "marcador"],
            "general": []
        }

    async def pipe(self, body: dict, **user) -> str:
        messages = body.get("messages", [])
        if not messages:
            return body

        msg = messages[-1].get("content", "")
        msg_lower = msg.lower()

        needs_search = any(
            kw in msg_lower
            for kws in self.keywords.values()
            for kw in kws
        )

        if needs_search:
            try:
                results = self.search.run(f"{msg} 2026")
                modified_content = f"[DATOS WEB ACTUALES (2026-05-05)]:\n{results}\n\n[PREGUNTA ORIGINAL]: {msg}"
                body["messages"][-1]["content"] = modified_content
            except Exception as e:
                pass

        return body

Requisitos: langchain-community

¿Cómo activarlo?

1. Ve a Admin Panel > Functions > + Create Function.
2. Pega el código anterior y guarda.
3. Ve a Workspace > Models > Selecciona tu modelo > Edit.
4. En la pestaña Functions, activa MoE Router.
5. Guarda los cambios.

Resultado: Ahora, cuando preguntes algo como “¿Cuál es el precio del dólar hoy?”, el Pipe inyectará automáticamente los resultados de búsqueda en el mensaje antes de que el modelo responda. Así, Qwen3.5 no podrá negarse a usar la información.

7. MoE Real vs. MoE de Agentes: ¿cuándo usar cada uno?

Mixture of Experts (MoE) es una arquitectura de modelos de IA donde varios “expertos” especializados trabajan juntos. Mixtral 8x7B es un ejemplo de MoE real, mientras que los agentes que creas en Open WebUI son una simulación de MoE mediante System Prompts y Tools.

Pro tip: Usa Mixtral 8x7B como modelo base en LM Studio y créale 5 agentes en Open WebUI (Contador, Diseñador, Programador, etc.). Así tendrás lo mejor de ambos mundos: el routing neuronal de Mixtral + la especialización controlada de los agentes.

8. Depuración: los 5 errores que todos cometen

Aquí tienes una tabla con los errores más comunes y cómo solucionarlos rápidamente:

9. Checklist: valida que todo funciona en 60 segundos

Sigue estos pasos para asegurarte de que todo está configurado correctamente:

1. LM Studio: Verifica que diga Server running on port 1234 en la pestaña Developer. ✅
2. Open WebUI: Abre en http://localhost:3000 y verifica que la conexión a LM Studio esté activa (verificación verde). ✅
3. Modelo: En el chat, selecciona Agente Cotizaciones (o el que hayas creado), no “Sugerido”. ✅
4. Prueba de búsqueda: Escribe: precio dólar hoy en México y Brasil. ✅
5. Verificación: Debes ver Calling get_exchange_rates... o Calling web_search.... ✅
6. Resultado: Debe responder con datos actualizados (ej: USD: 17.23 MXN, 5.08 BRL) y mostrar un enlace para descargar el archivo (si aplica). ✅

Si falla el paso 5:

• No activaste el Tool en el modelo.
• El System Prompt no es lo suficientemente agresivo.
• El Pipe no está activado.

10. Próximos niveles: ¿qué más puedes hacer?

Una vez que hayas dominado lo básico, puedes explorar estas ideas avanzadas:

• Agente de Clima:
  • Tool: Usa la API de OpenWeatherMap para obtener datos climáticos.
  • Salida: Genera una tarjeta visual con create_image.
• Agente de Trading:
  • Tool: Usa yfinance para obtener datos de acciones.
  • Salida: Genera un portafolio en Excel con create_excel.
• Agente de SEO:
  • Tool: Usa SerpAPI para búsquedas avanzadas en Google.
  • Salida: Genera reportes de palabras clave en PDF.
• MoE Router v2:
  • Pipe: Detecta el idioma de la pregunta y rutea a un agente en español, portugués o inglés.
  • Ejemplo: Si el usuario escribe en portugués, activa el agente de diseño en portugués.
• Integración con bases de datos:
  • Tool: Usa SQLite o PostgreSQL para consultar datos locales.
  • Ejemplo: Crea un agente que consulte una base de datos de clientes.
• Automatización con cron:
  • Tool: Usa schedule para ejecutar tareas programadas (ej: enviar cotizaciones diarias).

Glosario

Para que domines los términos técnicos usados en esta guía:

• Tool: Función en Python que el modelo puede llamar para realizar tareas específicas (búsquedas, generación de archivos, etc.).
• Pipe: Middleware. Modifica tu mensaje antes de que el modelo lo procese. Úsalo para forzar búsquedas o inyectar contexto.
• Agente: Combinación de un modelo base + System Prompt + Tools. Se crea en Workspace > Models. Es tu “experto” especializado.
• MoE (Mixture of Experts): Arquitectura de modelos de IA donde varios “expertos” trabajan juntos. Mixtral 8x7B es un ejemplo de MoE real.
• MoE Router: Pipe que simula el comportamiento de MoE ruteando preguntas a Tools específicos según palabras clave.
• System Prompt: Instrucciones predefinidas que configuran el comportamiento del modelo. Es clave para que use Tools correctamente.
• GGUF: Formato de archivo optimizado para modelos de lenguaje. Ejemplo: Qwen3.5-7B-Instruct.Q4_K_M.gguf.
• Function Calling: Capacidad de un modelo de IA para llamar funciones externas (Tools).
• VRAM: Memoria de video de la tarjeta gráfica. Determina qué modelos puedes ejecutar.
• API: Interfaz de programación que permite a diferentes sistemas comunicarse. Ejemplo: la API de exchangerate-api.com para tipos de cambio.