Implementación de modelos locales

Mucha gente piensa que la IA solo se puede usar en la nube: al usar ChatGPT, los datos se envían a los servidores de OpenAI; al usar Claude, las solicitudes se envían al centro de datos de Anthropic.

En realidad,Los modelos de IA pueden ejecutarse completamente en tu propia computadora.。

Imagina: puedes usar IA sin conexión, los datos confidenciales no salen de tu computadora, no necesitas pagar por cada llamada y puedes personalizarla como quieras.

Este es el valor de la implementación de modelos locales.

Este módulo te llevará desde cero para ejecutar tu primer modelo de IA local en tu propia computadora.

¿Por qué necesitas IA local?

La IA en la nube es muy conveniente, pero la IA local tiene ventajas irremplazables.

Protección de la privacidad de los datos

Esta es la razón principal por la que muchos eligen la implementación local.

Si lo que manejas son contratos, historiales médicos, datos financieros o documentos internos, enviar estos datos a servidores de terceros es arriesgado.

Cuando se ejecuta localmente,todos los datos se procesan en tu propia computadora y no salen de tu dispositivo.。

Uso en entornos sin red

En aviones, trenes o lugares con conexión inestable, la IA en la nube no se puede usar.

Una vez descargado el modelo local, está disponible para siempre sin necesidad de conexión de red.

Control de costos

La IA en la nube se cobra por número de llamadas o por token; si se usa mucho, puede ser un gasto considerable.

El modelo local se descarga una sola vez y luego se puede usar libremente sin pagos adicionales.

Posibilidad de personalización

Los modelos en la nube no se pueden modificar; solo puedes usar las funciones que ofrecen.

Los modelos locales se pueden ajustar (fine-tune), cuantizar, modificar las plantillas de prompts y personalizar completamente según tus necesidades.

Comparación de estas ventajas:

Característica	IA en la nube	IA local
Privacidad de datos	Los datos deben subirse	Datos completamente localizados
Dependencia de red	Debe estar en línea	Sin necesidad de red
Costo de uso	Cobro por uso	Descarga única, uso ilimitado
Capacidad de personalización	Limitada	Totalmente controlable
Facilidad de uso	Listo para usar	Requiere configuración
Velocidad de respuesta	Depende de la red	Depende del hardware

No es que la IA en la nube sea mala, sino quecada una tiene sus escenarios de aplicación.Para charlas cotidianas usa la nube, para datos confidenciales usa local; para tareas simples usa la nube, para personalización especial usa local.

Evaluación de requisitos de hardware

Si el modelo local puede ejecutarse y qué tan rápido lo hace depende principalmente de la configuración de tu hardware.

Inferencia en CPU vs inferencia en GPU

Hay dos formas de ejecutar modelos: inferencia en CPU e inferencia en GPU.

La inferencia en CPU usa el procesador principal de la computadora para ejecutar el modelo; la ventaja es una buena compatibilidad, casi todas las computadoras pueden hacerlo; la desventaja es que es lento, y con los modelos grandes puede requerir una larga espera.

La inferencia en GPU usa la tarjeta gráfica; la ventaja principal esla fuerte capacidad de cómputo paralelo, que hace que el modelo corra decenas de veces más rápido.。

Para tarjetas NVIDIA, necesitas instalar el kit de herramientas CUDA; para tarjetas AMD, puedes usar ROCm; para tarjetas Intel, puedes usar OpenVINO.

Relación entre la memoria de video (VRAM) y el tamaño del modelo

La memoria de video (VRAM) determina el tamaño del modelo que puedes ejecutar.

Cuantos más parámetros tiene el modelo, mayor es la VRAM necesaria. Pero con la cuantización, se puede ejecutar un modelo más grande con menos VRAM.

Tamaño de VRAM	Modelos ejecutables (FP16)	Modelos ejecutables (cuantizados)	Escenario recomendado
8 GB	Modelo 7B apenas	7B (Q4), 13B (Q4) apenas	Diálogos simples, tareas ligeras
16 GB	Modelos 7B, 13B	7B、13B（Q4/Q8）、33B（Q4）	Uso diario, mejor relación calidad-precio
24 GB	Modelos 7B, 13B, 33B	7B、13B、33B（Q4/Q8）、70B（Q4）	Uso profesional, experiencia fluida
48 GB+	Modelos 33B, 70B	Todos los modelos principales	Entornos de investigación y producción

Ventajas de la serie M de Mac

Apple Silicon (chips de las series M1, M2, M3) tiene ventajas únicas en IA local.

El framework Metal y la arquitectura de memoria unificada de Apple hacen que las Mac ejecuten modelos locales con alta eficiencia.

La memoria unificada significa quela CPU y la GPU comparten memoria,y cuando la VRAM no es suficiente, se puede tomar prestada memoria automáticamente.

Una MacBook Pro con 16GB de memoria unificada puede ejecutar modelos cuantizados de 7B y 13B con fluidez.

Configuraciones recomendadas

Según diferentes presupuestos y necesidades, aquí tienes varias opciones de configuración:

Opción	Configuración	Audiencia adecuada	Experiencia esperada
Plan de iniciación	Cualquier computadora (más de 8GB de RAM)	Novatos que quieren probar la IA local	Puede ejecutar modelos pequeños, lento
Plan de mejor relación calidad-precio	16GB de RAM + más de 6GB de VRAM	Uso diario personal	Modelos 7B/13B funcionan fluidamente
Plan profesional	32GB de RAM + más de 12GB de VRAM	Desarrolladores, investigadores	Modelo 33B funciona fluidamente
Plan para Mac	M1/M2/M3 + 16GB de memoria unificada	La mejor opción para usuarios de Mac	Modelos 7B/13B funcionan fluidamente

No te dejes intimidar por el término "gran modelo". La tecnología de cuantización actual ya permite ejecutar un modelo 7B fluidamente en una computadora normal, y la capacidad de un modelo 7B es suficiente para la mayoría de las tareas cotidianas.

Ollama: la herramienta de IA local más sencilla

Sitio web oficial de Ollama:https://ollama.com/
Lista de modelos compatibles con Ollama:https://ollama.com/search
Tutorial de Ollama:https://www.example.com/ollama/ollama-tutorial.html

Ollama es actualmente la herramienta de modelos locales más popular; en una frase:instala modelos como si instalaras una app, y usa la IA como si usaras la línea de comandos.。

Instalación y configuración

Ollama es compatible con macOS, Linux y Windows; el proceso de instalación es muy sencillo.

Dirección de descarga del paquete de instalación:https://ollama.com/download

Instalación con un solo comando:

curl -fsSL https://ollama.com/install.sh | sh

Los usuarios de macOS pueden descargar directamente el paquete de instalación o instalarlo con Homebrew:

# macOS 使用 Homebrew 安装
brew install ollama

# 或者下载安装包：https://ollama.com/download

Los usuarios de Windows pueden descargar el paquete de instalación directamente desde el sitio web oficial y ejecutarlo.

Después de la instalación, inicie el servicio de Ollama:

ollama serve

Una vez que vea que el servicio se inició correctamente, ya puede empezar a usarlo.

Descargar modelos

La biblioteca de modelos de Ollama es muy completa, e incluye modelos populares como Llama, Qwen, Gemma, Mistral, etc.

Para descargar un modelo solo necesita un comando:

Ejemplo

# Descargar Llama 3 (parámetros 8B)
ollama pull llama3

# Descargar Qwen (Tongyi Qianwen, amigable con el chino)
ollama pull qwen

# Descargar Gemma (creado por Google)
ollama pull gemma

# Descargar Mistral
ollama pull mistral

También se puede usarollama run + nombre del modelocomando; si no existe el modelo especificado, se descargará automáticamente:

ollama run qwen

Ejecute el modelo qwen; si no está disponible, se descargará.

Cada modelo tiene diferentes versiones, como 8B, 70B, o diferentes versiones cuantizadas.

Puede usarollama listpara ver los modelos ya descargados:

ollama list

La salida es similar a:

NAME              ID              SIZE      MODIFIED
qwen3.5:latest    6488c96fa5fa    6.6 GB    3 months ago

Uso desde la línea de comandos

Una vez descargado el modelo, puede ejecutarlo directamente para comenzar a conversar:

# 运行 Llama 3，没有会下载
ollama run llama3

# 运行 Qwen，没有会下载
ollama run qwen3.5

qwen3.5 es más que suficiente para tareas comunes:

Luego puede conversar directamente con el modelo:

>>> 你好，请介绍一下你自己
你好！我是 Llama 3，由 Meta 开发的 AI 助手。我可以帮你回答问题、
写作、编程、分析数据等。有什么我可以帮你的吗？

>>> 用 Python 写一个 Hello World 程序
好的，这是一个简单的 Python Hello World 程序：

print("Hello, World!")

>>> /bye  # 输入 /bye 退出

Comandos comunes:

Comando	Función	Ejemplo
ollama pull <model>	Descargar modelo	ollama pull llama3
ollama run <model>	Ejecutar modelo	ollama run llama3
ollama list	Listar modelos instalados	ollama list
ollama rm <model>	Eliminar modelo	ollama rm llama3
ollama show <model>	Ver información del modelo	ollama show llama3

Llamadas a la API

Ollama incluye una API HTTP; puede llamarla con código, no solo desde la línea de comandos.

De forma predeterminada, Ollama está enhttp://localhost:11434y ofrece el servicio API.

Usar Python para llamar a la API de Ollama:

Ejemplo

# Ruta del archivo: /Users/ejemplo/ollama_test.py
# Llamar a la API de Ollama con Python

import requests
import json

# Dirección de la API de Ollama
OLLAMA_URL = "http://localhost:11434/api/generate"

def ask_ollama(prompt: str, model: str = "llama3") -> str:
"""
Enviar una solicitud a Ollama y obtener la respuesta del modelo

Args:
prompt: el mensaje (prompt) ingresado por el usuario
model: el nombre del modelo utilizado, por defecto llama3

Returns:
El texto de respuesta del modelo
"""
# Construir los datos de la solicitud
payload = {
"model": model, # Modelo utilizado
"prompt": prompt, # Entrada del usuario
"stream": False # No usar salida en streaming, devolver todo de una vez
}

try:
# Enviar solicitud POST
response = requests.post(OLLAMA_URL, json=payload)
response.raise_for_status() # Verificar si la solicitud fue exitosa

# Analizar el JSON devuelto
result = response.json()
return result.get("response", "")

except requests.exceptions.ConnectionError:
return "Error: no se puede conectar al servicio de Ollama, asegúrese de que Ollama esté iniciado"
except requests.exceptions.RequestException as e:
return f"Error de solicitud: {str(e)}"

# Probemos
if __name__ == "__main__":
# Pregunta de prueba 1
question1 = "Presenta el tutorial de EJEMPLO en una frase"
answer1 = ask_ollama(question1)
print(f"Pregunta: {question1}")
print(f"Respuesta: {answer1}")
print("-" * 50)

# Pregunta de prueba 2
question2 = "Escribe una función en Python que calcule la secuencia de Fibonacci"
answer2 = ask_ollama(question2)
print(f"Pregunta: {question2}")
print(f"Respuesta: {answer2}")

Ejecute este script:

Ejemplo

# Primero instale la biblioteca requests (si aún no está instalada)
pip install requests

# Ejecutar el script
python ollama_test.py

Si desea una capa de abstracción más avanzada, puede usar la biblioteca oficial de Python de Ollama:

Ejemplo

# Ruta del archivo: /Users/ejemplo/ollama_advanced.py
# Usar la biblioteca Python de Ollama

# Instalar primero: pip install ollama

import ollama

def chat_with_ejemplo():
"""
Usar la biblioteca Python de Ollama para conversaciones de múltiples turnos
"""
# Historial de mensajes
messages = [
{
"role": "system",
"content": "Eres un asistente de programación amigable llamado EjemploBot. Tus respuestas deben ser concisas, prácticas y con muchos ejemplos de código."
}
]

print("EjemploBot iniciado. Escribe 'quit' para salir.")
print("-" * 50)

while True:
# Obtener la entrada del usuario
user_input = input("Tú:")

if user_input.lower() in ["quit", "exit", quit]:
print("¡Adiós!")
break

# Agregar el mensaje del usuario al historial
messages.append({
"role": "user",
"content": user_input
})

# Llamar al modelo
response = ollama.chat(
model="llama3",
messages=messages
)

# Obtener la respuesta
assistant_message = response["message"]["content"]
print(f"EjemploBot：{assistant_message}")
print("-" * 50)

# Agregar la respuesta del asistente al historial
messages.append({
"role": "assistant",
"content": assistant_message
})

if __name__ == "__main__":
chat_with_ejemplo()

Integración con Open WebUI

Aunque la línea de comandos es conveniente, una interfaz gráfica es más amigable.

Open WebUI es una interfaz web muy bonita que se puede conectar a Ollama, permitiéndole usar modelos locales como si usara ChatGPT.

Instalar Open WebUI:

Ejemplo

# Instalar Open WebUI con Docker
docker run -d -p 3000:8080 --add-host=host.docker.internal:host-gateway -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:main

# Si no usa Docker, también puede instalarlo con pip
pip install open-webui
open-webui serve

Después de la instalación, abra en el navegadorhttp://localhost:3000y verá una interfaz muy similar a ChatGPT.

Ollama + Open WebUI es actualmente la combinación de IA local más recomendada: instalación sencilla, interfaz amigable y potente, adecuada para la gran mayoría de los usuarios.

LM Studio: operación con interfaz gráfica

Si no le gusta la línea de comandos, LM Studio es una excelente opción:Interfaz totalmente gráfica: descargar y ejecutar modelos se hace en ventanas.。

Instalar LM Studio

LM Studio es compatible con Windows, macOS y Linux.

Desde el sitio web oficialhttps://lmstudio.aidescargue el paquete de instalación e instálelo directamente.

Descarga y gestión de modelos

Abra LM Studio, a la izquierda está la biblioteca de modelos.

Puede buscar por nombre de modelo, por ejemplo "llama", "qwen", "mistral", encontrar el modelo deseado y hacer clic en descargar.

LM Studio mostrará automáticamente las diferentes versiones del mismo modelo:

Versión	Descripción	Escenario recomendado
Q4_K_M	Cuantización de 4 bits, poca pérdida de calidad	La elección de la mayoría
Q5_K_M	Cuantización de 5 bits, mejor calidad, tamaño un poco mayor	Elija esta opción si tiene suficiente memoria de video (VRAM)
Q8_0	Cuantización de 8 bits, calidad cercana a la original	Para quienes buscan calidad y tienen suficiente VRAM
FP16	Precisión completa, tamaño más grande	Para fines de investigación

Los modelos descargados aparecerán en la lista "My Models".

Servicio de API local

LM Studio también puede ofrecer un servicio API, compatible con el formato de API de OpenAI.

Esto significa que el código que escriba para OpenAI solo necesita cambiar la dirección de la API y la clave (Key) para usar modelos locales.

Ejemplo

# Ruta del archivo: /Users/ejemplo/lmstudio_openai.py
# LM Studio compatible con el formato de API de OpenAI

from openai import OpenAI

# Conectar al servidor local de LM Studio
# Nota: primero debe iniciar el servidor en LM Studio
client = OpenAI(
base_url="http://localhost:1234/v1",
api_key="lm-studio" # LM Studio solo necesita este marcador de posición
)

def ask_local_model(prompt: str, system_prompt: str = "Eres un asistente útil.") -> str:
"""
Llamar al modelo local de LM Studio a través de la interfaz compatible con OpenAI
"""
response = client.chat.completions.create(
model="local-model", # Este campo será ignorado por LM Studio
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": prompt}
],
temperature=0.7,
)
return response.choices[0].message.content

# Prueba
if __name__ == "__main__":
question = "Presenta las características del tutorial de EJEMPLO"
answer = ask_local_model(
prompt=question,
system_prompt="Eres el servicio de atención al cliente exclusivo de Ejemplo, respondes profesionalmente preguntas sobre el aprendizaje de programación."
)
print(f"Pregunta: {question}")
print(f"Respuesta: {answer}")

Esta característica es muy útil: puede usar el mismo código para cambiar entre modelos en la nube y modelos locales según sea necesario.

Para los usuarios que recién comienzan con IA local, recomiendo: primero usar LM Studio para familiarizarse con los conceptos y operaciones básicas; luego, una vez familiarizados, usar Ollama para automatización e integración.

Introducción a la cuantización de modelos

La cuantización es una tecnología clave para hacer que los modelos grandes funcionen en computadoras comunes:Ejecutar modelos más grandes con menos memoria de video, manteniendo la mayor parte de la capacidad。

¿Qué es la cuantización?

En pocas palabras, la cuantización consiste en reducir la precisión de los parámetros del modelo.

Los modelos nativos suelen almacenar cada parámetro usando números de punto flotante de 16 bits (FP16) o de 32 bits (FP32).

Después de la cuantización, almacenamos con enteros de 8 bits (INT8) e incluso enteros de 4 bits (INT4).

La precisión se reduce, pero el tamaño y los requisitos de memoria de video también se reducen considerablemente.

Por ejemplo:

Precisión	Tamaño del modelo 7B	Tamaño del modelo 13B	Requisitos de memoria de video	Pérdida de calidad
FP16	13 GB	26 GB	Alto	Ninguno
Q8_0	7 GB	13 GB	Medio	Muy pequeña
Q5_K_M	5 GB	9 GB	bajo	Aceptable
Q4_K_M	4 GB	7 GB	Muy bajo	Leve
Q3_K_M	3 GB	5 GB	Extremadamente bajo	Notable

La experiencia es: con la cuantización Q8 apenas se nota una pérdida de calidad, y la cuantización Q4 es suficiente para la mayoría de las tareas.

Explicación detallada del formato GGUF

GGUF es actualmente el formato de modelo cuantizado más popular.

El predecesor de GGUF es GGML, desarrollado por el proyecto llama.cpp.

Las ventajas de este formato:

Primero,Buena compatibilidad multiplataforma—Funciona en Windows, macOS y Linux, y puede ejecutarse tanto en CPU como en GPU.
Segundo,Admite múltiples niveles de cuantización—Desde FP16 hasta Q3, elige según tus necesidades.
Tercero,Velocidad de inferencia rápida—Se ha optimizado ampliamente para CPU y GPU.

Ahora la mayoría de las herramientas de modelos locales (Ollama, LM Studio, llama.cpp) admiten el formato GGUF.

Diferencias entre cuantización Q4/Q8

Q4 y Q8 son los dos niveles de cuantización más utilizados.

La cuantización Q8 es de 8 bits; cada parámetro se almacena con un entero de 8 bits. La ventaja de Q8 espérdida de calidad mínima, casi idéntica al modelo original; la desventaja es que el tamaño aún no es lo suficientemente pequeño.
La cuantización Q4 es de 4 bits; cada parámetro se almacena con un entero de 4 bits. La ventaja de Q4 estamaño pequeño y alta velocidad; la desventaja es que la calidad disminuye notablemente en tareas complejas.

Cómo elegir:

Escenario	Nivel de cuantización recomendado	Razón
Memoria de video muy limitada (menos de 8 GB)	Q4_K_M	Que funcione es lo primero
Conversación diaria, tareas simples	Q4_K_M	Mejor relación calidad-precio
Escritura, programación, análisis	Q5_K_M o Q6_K	Equilibrio entre calidad y velocidad
Buscando la mejor calidad	Q8_0	Cerca de la calidad original

Esquemas de cuantización AWQ/GPTQ

Además del método de cuantización de GGUF, existen otros dos esquemas comunes: AWQ y GPTQ.

AWQ (Activation-aware Weight Quantization) se caracteriza porconservar los pesos que más influyen en el resultado, lo que reduce la pérdida de calidad tras la cuantización.

GPTQ (Gradient-based Post-Training Quantization) se caracteriza porutilizar información de gradientes para optimizar la cuantización, adecuado para escenarios con GPU.

Estos dos esquemas se utilizan principalmente en tarjetas gráficas NVIDIA con soporte CUDA.

Comparación sencilla:

Esquema de cuantización	Hardware compatible	Velocidad	Calidad	Herramienta recomendada
GGUF	CPU + varios GPU	Rápido	Bien	Ollama、LM Studio
AWQ	NVIDIA GPU	Muy rápida	Muy buena	vLLM、Text Generation WebUI
GPTQ	NVIDIA GPU	Muy rápida	Muy buena	AutoGPTQ、ExLlama

Para principiantes, no te preocupes por estos detalles técnicos: simplemente usa la versión Q4_K_M recomendada en Ollama o LM Studio; es el punto de equilibrio óptimo, ampliamente validado.

Guía para elegir modelos

Hoy en día hay cientos de miles de modelos de código abierto; es importante elegir uno que se adapte a ti.

Comparación de modelos 7B/13B/70B

El número de parámetros del modelo es un indicador importante: 7B, 13B y 70B son las especificaciones más comunes.

Especificación	Requisitos de memoria de video (Q4)	Velocidad de inferencia	Nivel de capacidad	Escenarios adecuados
7B	4-6 GB	Muy rápida	Suficiente	Conversación diaria, tareas simples
13B	7-10 GB	Rápido	Buena	Escritura, programación, análisis
33B	15-20 GB	Media	Excelente	Razonamiento complejo, áreas profesionales
70B	30-40 GB	Más lenta	Cerca de GPT-3.5	Investigación, entornos de producción

Para la mayoría de las personas, el punto óptimo (sweet spot) es la versión cuantizada 13B Q4: tiene buenas capacidades y una velocidad aceptable.

Recomendación de modelos con buen soporte para chino

Muchos modelos extranjeros tienen habilidades mediocres en chino; aquí recomendamos algunos modelos amigables con el chino:

Nombre del modelo	Creador	Características	Comando de Ollama
Qwen (Tongyi Qianwen)	Alibaba	Gran capacidad en chino y habilidades generales equilibradas	ollama pull qwen
Yi (01.AI)	01.AI	Buena comprensión del chino y fuerte capacidad de razonamiento	ollama pull yi
DeepSeek	DeepSeek	Fuerte en código, buen chino	ollama pull deepseek-coder
Llama 3	Meta	Habilidades generales fuertes, pero el chino necesita ajustes	ollama pull llama3
Gemma	Google	Base sólida, buena capacidad de código	ollama pull gemma

Para tareas en chino, Qwen es la primera opción; su comprensión y generación de chino están en el primer nivel entre los modelos de código abierto.

Selección de modelos según la tarea

Cada modelo tiene sus especialidades; elige según la tarea:

Tipo de tarea	Modelo recomendado	Razón
Conversación diaria, preguntas y respuestas	Llama 3、Qwen、Mistral	Habilidades generales equilibradas
Escritura, redacción publicitaria	Yi, Llama 3, Claude (nube)	Buen estilo de escritura, expresión fluida
Programación, código	DeepSeek-Coder、CodeLlama、StarCoder	Fuerte capacidad para comprender y generar código
Matemáticas, razonamiento	Llama 3、Qwen、WizardMath	Buena capacidad de razonamiento lógico
Áreas especializadas (medicina, derecho)	Modelos ajustados según el dominio	Entrenados con datos especializados

Los modelos no son mejores cuanto más grandes, ni cuanto más nuevos—que se adapten a tu hardware y a tu tareason los mejores. Se recomienda descargar algunos modelos 7B para probar y, una vez que te familiarices, actualizar.

Práctica: construir una base de conocimiento local completamente offline

Uno de los casos de uso más prácticos de los modelos locales es crear tu propia base de conocimiento privada:alimentar el modelo con documentos locales para que responda preguntas basadas en esos documentos.。

Todo el sistema funciona completamente fuera de línea; los datos no salen de tu computadora.

Solución técnica

Usamos la tecnología RAG (Generación Aumentada por Recuperación):

1. Dividir los documentos en fragmentos pequeños

2. Usar un modelo de incrustación para convertir cada fragmento en un vector

3. Almacenar los vectores en una base de datos vectorial

4. Al hacer una pregunta, convertir también la pregunta en vector

5. Encontrar los fragmentos de documento más relevantes en la base de datos vectorial

6. Enviar los documentos relevantes junto con la pregunta al modelo local grande

7. El modelo grande responde basándose en el contenido de los documentos

Este proceso suena complejo, pero con herramientas existentes es muy sencillo.

Implementación con Ollama + LangChain

Usamos Python para implementar una versión sencilla:

Ejemplo

# Ruta del archivo: /Users/ejemplo/local_knowledge_base.py
# Sistema RAG de base de conocimiento local completamente fuera de línea

# Primero instala las dependencias:
# pip install langchain langchain-ollama chromadb pypdf

from langchain_ollama import OllamaLLM, OllamaEmbeddings
from langchain_community.document_loaders import PyPDFLoader, TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import Chroma
from langchain.chains import RetrievalQA
import os

class LocalKnowledgeBase:
"""Clase de base de conocimiento local, implementa funcionalidad RAG completamente fuera de línea"""

def __init__(self, model_name: str = "llama3", persist_dir: str = "./chroma_db"):
"""
Inicializar la base de conocimiento

Args:
model_name: nombre del modelo Ollama a usar
persist_dir: directorio de persistencia de la base de datos vectorial
"""
self.model_name = model_name
self.persist_dir = persist_dir

# 1. Inicializar el LLM (modelo local)
self.llm = OllamaLLM(model=model_name)

# 2. Inicializar el modelo de incrustación (incrustación local)
# Usa nomic-embed-text, este modelo funciona bien tanto en chino como en inglés
self.embeddings = OllamaEmbeddings(model="nomic-embed-text")

# 3. Marcador de posición de la base de datos vectorial
self.vector_store = None
self.qa_chain = None

def load_documents(self, document_paths: list):
"""
Cargar documentos y construir la base de datos vectorial

Args:
document_paths: lista de rutas de documentos
"""
documents = []

for path in document_paths:
if not os.path.exists(path):
print(f"Advertencia: el archivo {path} no existe, se omite")
continue

# Seleccionar el cargador según la extensión del archivo
if path.lower().endswith(".pdf"):
loader = PyPDFLoader(path)
elif path.lower().endswith(".txt"):
loader = TextLoader(path, encoding="utf-8")
else:
print(f"Advertencia: tipo de archivo no compatible {path}, se omite")
continue

documents.extend(loader.load())
print(f"Cargado: {path}")

if not documents:
print("No se cargó ningún documento correctamente")
return

print(f"Se cargaron en total {len(documents)} fragmentos de documentos")

# 4. Dividir el documento
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=500, # Cada bloque 500 caracteres
chunk_overlap=100 # Superposición de 100 caracteres entre bloques
)
split_docs = text_splitter.split_documents(documents)
print(fDividido en {len(split_docs)} fragmentos)

# 5. Construir la base de datos vectorial
print(Construyendo la base de datos vectorial...)
self.vector_store = Chroma.from_documents(
documents=split_docs,
embedding=self.embeddings,
persist_directory=self.persist_dir
)
print(¡Base de datos vectorial construida!)

# 6. Construir la cadena de preguntas y respuestas
self._build_qa_chain()

def _build_qa_chain(self):
"""Construir la cadena de preguntas y respuestas RAG"""
if not self.vector_store:
print(¡Por favor, cargue primero el documento!)
return

# Construir el recuperador
retriever = self.vector_store.as_retriever(
search_type="similarity",
search_kwargs={"k": 3} # Devolver los 3 fragmentos más relevantes
)

# Construir la cadena RAG
self.qa_chain = RetrievalQA.from_chain_type(
llm=self.llm,
chain_type="stuff",
retriever=retriever,
return_source_documents=True
)

def load_existing_db(self):
"""Cargar la base de datos vectorial existente"""
if os.path.exists(self.persist_dir):
self.vector_store = Chroma(
persist_directory=self.persist_dir,
embedding_function=self.embeddings
)
self._build_qa_chain()
print(Se ha cargado la base de datos vectorial existente)
return True
else:
print(No se encontró ninguna base de datos vectorial existente)
return False

def ask(self, question: str) -> dict:
"""
Hacer preguntas a la base de conocimiento

Args:
question: pregunta

Returns:
Diccionario que contiene la respuesta y las fuentes de referencia
"""
if not self.qa_chain:
return {"error": ¡Cargue primero el documento o la base de datos existente!}

# Construir una plantilla de prompt para fomentar respuestas en chino
result = self.qa_chain.invoke({
"query": f"""Por favor, responda las siguientes preguntas en chino. Si la respuesta está en el contexto, indíquelo claramente.
Si no hay respuesta en el contexto, diga honestamente "no se puede responder según la información proporcionada".

Pregunta: {question}
"""
})

return {
"question": question,
"answer": result["result"],
"sources": [doc.page_content for doc in result["source_documents"]]
}

# ============================================
# Ejemplo de uso
# ============================================

if __name__ == "__main__":
# 1. Crear una instancia de la base de conocimiento
kb = LocalKnowledgeBase(model_name="qwen") # Usar Qwen, mejor para chino

# 2. Intentar cargar la base de datos existente; de lo contrario, cargar el documento
if not kb.load_existing_db():
# Preparar algunos documentos, por ejemplo, guardar algunos tutoriales de EJEMPLO como txt
sample_docs = [
"/Users/ejemplo/documents/ejemplo_python_tutorial.txt",
"/Users/ejemplo/documents/company_handbook.pdf",
]
kb.load_documents(sample_docs)

# 3. Preguntas y respuestas interactivas
print("=" * 50)
print(¡La base de conocimiento local de Ejemplo se ha iniciado!)
print(Ingrese su pregunta, o escriba 'quit' para salir)
print("=" * 50)

while True:
user_input = input("\nSu pregunta:)

if user_input.lower() in ["quit", "exit", Salir]:
print(¡Adiós!)
break

if not user_input.strip():
continue

# Preguntar
result = kb.ask(user_input)

if "error" in result:
print(fError: {result['error']})
continue

print(f"\nRespuesta: {result['answer']})
print("\nFuentes de referencia:)
for i, source in enumerate(result["sources"], 1):
print(f"\n[{i}] {source[:200]}...")

Antes de usar este sistema, es necesario descargar el modelo de incrustación:

Ejemplo

# Descargar el modelo de incrustación
ollama pull nomic-embed-text

# Descargar el modelo principal (si aún no se ha descargado)
ollama pull qwen

Así tendrás un sistema de base de conocimiento privado que se ejecuta completamente en local.

Puedes poner tus notas, documentos y libros electrónicos y dejar que la IA te ayude a buscar y responder preguntas.

Todos los datos de este sistema están en tu equipo: los documentos en tu disco duro, la base de datos vectorial en tu directorio y el modelo en tu computadora; no tienes que preocuparte por fugas de datos.

Consejos para optimizar el rendimiento

El modelo local ya está funcionando, pero ¿cómo hacer que vaya más rápido? Aquí tienes algunos consejos prácticos.

Elegir el nivel de cuantización adecuado

Esta es la optimización más sencilla y eficaz: cuanto menor sea el nivel de cuantización, mayor será la velocidad.

Si Q4 funciona, no uses Q8; si Q8 funciona, no uses FP16.

Ajustar el tamaño de la ventana de contexto

Cuanto mayor sea la ventana de contexto, más cálculo se requiere.

Si no necesitas un contexto muy largo, puedes configurarlo en el Modelfile de Ollama:

Ejemplo

# Crear un modelo personalizado, limitar la ventana de contexto
# Crear un nuevo archivo Modelfile

echo "FROM llama3
PARAMETER num_ctx 2048" > Modelfile

# Crear el modelo personalizado
ollama create llama3-fast -f Modelfile

# Ejecutar
ollama run llama3-fast

Reducir el contexto de los 8192 predeterminados a 2048 hará que sea bastante más rápido.

Usar aceleración por GPU

Si tienes una tarjeta gráfica NVIDIA o Apple Silicon en tu Mac, asegúrate de que Ollama esté usando la GPU en lugar de la CPU.

Ollama detecta y usa la GPU automáticamente, pero a veces conviene comprobarlo.

En el registro de inicio de Ollama, deberías ver información similar a "Metal GPU activated" o "CUDA activated".

Usar parámetros de muestreo más rápidos

Algunos parámetros de muestreo afectan la velocidad:

Ejemplo

# Crear un Modelfile optimizado para la velocidad
# Archivo: Modelfile.fast

echo "FROM llama3
PARAMETER temperature 0.7
PARAMETER top_k 20
PARAMETER top_p 0.9
PARAMETER num_predict 256" > Modelfile.fast

# Crear y ejecutar
ollama create llama3-optimized -f Modelfile.fast
ollama run llama3-optimized

Descripción de parámetros:

Parámetro	Función	Sugerencia de optimización
temperature	Controlar la aleatoriedad	Con moderación es suficiente, no afecta la velocidad
top_k	Limitar el número de palabras candidatas	Ponerlo más pequeño (20-40) puede acelerar
top_p	Umbral de probabilidad acumulativa	El valor predeterminado de 0.9 está bien
num_predict	Número máximo de tokens generados	Limitarlo según sea necesario
num_ctx	Tamaño de la ventana de contexto	Con que sea suficiente, cuanto más pequeño, más rápido

Desactivar funciones innecesarias

Si usas llamadas a la API y no necesitas salida en streaming, puedes establecer stream en false.

Aunque esto no hará que la inferencia sea más rápida, reducirá la sobrecarga de transferencia de red.

La optimización del rendimiento es un arte de equilibrio: velocidad, calidad y memoria de video; no se pueden tener las tres a la vez. Según tus necesidades, solo tienes que encontrar el punto de equilibrio adecuado para ti.

Otras extensiones