Introducción al Desarrollo de Agentes

La creación de un agente de IA implica integrar capacidades de memoria, conocimiento y herramientas con un modelo de lenguaje grande (LLM). Este enfoque supera las limitaciones de un LLM puro, permitiendo realizar tareas complejas de manera autónoma. Un agente se puede conceptualizar como: LLM + Memoria + Conocimiento + Herramientas.

Existen marcos de trabajo (frameworks) que facilitan esta itnegración. Ejemplos populares incluyen LlamaIndex, LangChain y Phidata, cada uno con sus propias fortalezas para orquestar la interacción entre el LLM y los componentes externos.

Modelos de Lenguaje Grandes (LLM)

Los LLM como LLaMA (de Meta) o Qwen (de Alibaba) son redes neuronales basadas en la arquitectura Transformer, que utiliza mecanismos de autoatención. Estos modelos pueden ejecutarse de diversas maneras:

• Ollama: Es una herramienta para gestionar y ejecutar LLM localmente de forma sencilla. Soporta modelos en formato GGUF. Sus comandos básicos son: ollama serve, ollama list y ollama run <modelo>.
• Biblioteca Transformers (de Hugging Face): Un marco más completo y flexible. Ofrece múltiples niveles de abstracción (Pipeline, AutoModel, modelos específicos), acceso a miles de modelos preentrenados y herramientas para entrenamiento. Requiere más conocimientos técnicos.
• API de OpenAI: Ha surgido como un estándar de facto para interactuar con LLMs. Cualquier modelo puede ofrecer una interfaz compatible. Por ejemplo, para usar Ollama con esta API:

from openai import OpenAI

client = OpenAI(
    base_url='http://localhost:11434/v1',
    api_key='not-needed'
)

response = client.chat.completions.create(
    model="llama3.1:8b",
    messages=[
        {"role": "system", "content": "Eres un asistente servicial."},
        {"role": "user", "content": "¿Qué es la autoatención?"}
    ]
)
print(response.choices[0].message.content)

Los modelos suelen diferenciarse entre modelos base (preentrenados) y modelos Instruct, que han sido ajustados específicamente para seguir instrucciones de los usuarios, siendo más "listos para usar" en tareas conversacionales.

Arquitectura y Plantillas (Templates)

La arquitectura Transformer permite el procesamiento paralelo y captura de dependencias a largo plazo. Para interacciones, los LLMs usan plantillas que estructuran el prompt, separando claramente el contexto del sistema, el historial del usuario y las respuestas previas.

Ejemplo de plantilla para un chat:

<|inicio_sistema|>
Tú eres un asistente experto en historia.
<|fin_sistema|>
<|inicio_usuario|>
¿Cuándo se fundó Roma?
<|fin_usuario|>
<|inicio_asistente|>

El campo system es crucial, ya que define el comportamiento y las capacidades del modelo. Para un agente, este campo especifica las herramientas disponibles y su uso. Las plantillas varían entre modelos (Qwen, ChatML, etc.), y marcos como SWIFT manejan esta heterogeneidad internamente.

Modelos de Incrustación (Embeddings) y RAG

Los modelos de incrustación transforman texto en vectores numéricos densos que capturan su significado semántico. Son la columna vertebral de técnicas como la Ganeración Aumentada por Recuperación (RAG).

La arquitectura BERT (y sus variantes como RoBERTa, DistilBERT) introdujo el preentrenamiento bidireccional (MLM) y sentó las bases para muchos modelos de incrustación posteriores. Para mejorar RAG, se pueden usar:

• Modelos de Reordenamiento (Rerank): Como bge-reranker-large, que reordenan los documentos recuperados por relevancia.
• Modelos de Incrustación más recientes: Como los de la familia Qwen3.

Entrenamiento y Ajuste Fino (Fine-Tuning)

El ajuste fino adapta un modelo base a una tarea o dominio específico con datos etiquetados. Se puede realizar de menera sencilla con bibliotecas como Transformers:

from transformers import AutoModelForSequenceClassification, Trainer, TrainingArguments
from datasets import load_dataset

dataset = load_dataset("imdb")
tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")

def tokenize(examples):
    return tokenizer(examples["text"], truncation=True, padding=True)

tokenized_dataset = dataset.map(tokenize, batched=True)

model = AutoModelForSequenceClassification.from_pretrained("bert-base-uncased", num_labels=2)

training_args = TrainingArguments(
    output_dir="./results",
    num_train_epochs=3,
    per_device_train_batch_size=8,
    evaluation_strategy="epoch",
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_dataset["train"],
    eval_dataset=tokenized_dataset["test"],
)

trainer.train()

Para entrenamientos más exigentes en múltiples GPUs, se utilizan marcos como DeepSpeed, que optimizan la memoria y la eficiencia mediante técnicas como la partición de estados (ZeRO).

import deepspeed

# Configuración básica de DeepSpeed
ds_config = {
    "train_batch_size": 64,
    "fp16": {"enabled": True},
    "zero_optimization": {"stage": 2}
}

# Inicialización con DeepSpeed
model_engine, optimizer, _, _ = deepspeed.initialize(
    model=model,
    config=ds_config,
    model_parameters=model.parameters()
)

# Bucle de entrenamiento
for batch in dataloader:
    loss = model_engine(batch)
    model_engine.backward(loss)
    model_engine.step()

Plataformas como ModelScope (魔搭社区) ofrecen entornos preconfigurados con herramientas como swift para simplificar tanto la inferencia (swift infer) como el despliegue (swift deploy) de modelos, incluyendo ajustes con LoRA.

Ecosistema y Herramientas Adicionales

Keras 3 proporciona una interfaz unificada para múltiples backends (TensorFlow, PyTorch, JAX). Los benchmarks recientes muestran que JAX a menudo ofrece un rendimiento superior.

Distribución de Modelos: Los modelos se pueden descargar desde repositorios como Hugging Face Hub (usando espejos como hf-mirror.com si es necesario) o ModelScope, que suelen ser más rápidos en ciertas regiones.

Paradigmas de Agentes: Los marcos implementan diversos patrones de razonamiento para los agentes, como ReAct (Observar-Pensar-Actuar en un bucle), Cadenas de Pensamiento (CoT) y Árboles de Pensamiento (ToT).