Cursus — Call Me Maybe pendiente

Introducción al function calling de los LLM: convertir una petición en lenguaje natural en una llamada a función en JSON válido, guiando a un modelo pequeño token a token. Proyecto de Python del rank 03 de 42next.

De dónde viene — Un modelo de lenguaje solo sabe hacer una cosa: dado un texto, dar una puntuación a cada posible trozo siguiente. Eso sirve para conversar, pero un programa no entiende «La suma de 40 y 2 es 42»; entiende {"name": "fn_add_numbers", "parameters": {"a": 40.0, "b": 2.0}}. Desde 2023 las API de los grandes modelos ofrecen function calling (o tool use): el modelo no responde, sino que dice qué función de tu programa hay que llamar y con qué argumentos. Es la pieza sobre la que se montan los asistentes que consultan bases de datos, los agentes y las herramientas de extracción de datos. El problema es que los modelos pequeños son poco fiables generando estructura: el enunciado dice que, pidiéndole JSON a un modelo de 0,6B parámetros, quizá acierte un 30 % de las veces. La solución industrial no es pedírselo mejor, sino no dejarle equivocarse: el constrained decoding (decodificación restringida), que filtra a cada paso los tokens que romperían la estructura. Es lo que hacen por dentro librerías como Outlines o las gramáticas de llama.cpp — y precisamente esas librerías están prohibidas aquí: hay que construirlo a mano. El enunciado está hecho en colaboración con estudiantes (ldevelle, pcamaren y crfernan).

Qué pide

Rank: 03 Lenguaje: Python ≥ 3.10 Modelo: Qwen/Qwen3-0.6B Gestor: uv Individual/grupo: no confirmado

Una herramienta que lee una lista de peticiones en lenguaje natural y un catálogo de funciones, y para cada petición escribe qué función llamar y con qué argumentos, usando el LLM para decidirlo y constrained decoding para garantizar un JSON 100 % válido y conforme al esquema.

Reglas comunes de los proyectos de Python de 42next (las mismas de los Python Module): flake8, anotaciones de tipo en todo con mypy sin errores, docstrings PEP 257, excepciones controladas (si el programa revienta en la evaluación, se considera no funcional), recursos con context managers, y un Makefile con install, run, debug, clean, lint (y lint-strict opcional).

Requisitos propios del proyecto:

01Qué es el function calling

El ejemplo del propio enunciado:

Usuario:          "What is the sum of 40 and 2?"
LLM tradicional:  "The sum of 40 and 2 is 42."
Function calling: {"function": "add_numbers", "arguments": {"a": 40.0, "b": 2.0}}

El sistema no responde la pregunta: devuelve las herramientas para resolverla, el nombre de la función correcta y sus argumentos con el tipo correcto. Ejecutarla ya es cosa de otro programa (y en este proyecto, de nadie: solo se pide la llamada).

Qué te obliga a aprender — La diferencia entre generar texto y generar datos. El primer caso tolera erratas; el segundo no tolera ni una coma de más, porque lo va a leer json.loads, no una persona. Es la misma idea que el parseo estricto de A-Maze-ing o Fly-in, pero al revés: ahí te tocaba rechazar entrada mal formada; aquí te toca garantizar que la salida nunca lo esté.

02Entrada, salida y uso

Se ejecuta así (src es la carpeta con tu código):

uv run python -m src [--functions_definition <fichero>] [--input <fichero>] [--output <fichero>]

Por defecto lee de data/input/ y escribe en data/output/. Dos ficheros de entrada:

La salida es un único fichero, data/output/function_calls.json, con un objeto por petición que tiene exactamente tres claves:

[
  {
    "prompt": "What is the sum of 2 and 3?",
    "name": "fn_add_numbers",
    "parameters": {"a": 2.0, "b": 3.0}
  }
]

Reglas de validación: JSON válido (sin comas finales ni comentarios), claves y tipos idénticos al esquema del catálogo, ningún texto ni clave extra, todos los argumentos obligatorios presentes y con su tipo (number, string, boolean…). Los ficheros de entrada pueden cambiar en la evaluación, y pueden llegar con JSON inválido o no existir: hay que manejarlo.

En el repositorio van src/, pyproject.toml y uv.lock, una copia de llm_sdk/, data/input/ con ficheros de prueba y el README. El directorio de salida no se sube.

03Tokens, logits y el SDK

El enunciado explica la tubería de generación de un LLM:

Prompt → Tokenización → IDs de entrada → LLM → Logits → Elección del siguiente token

El texto se trocea en tokens, que no son palabras sino subpalabras (con algoritmos como BPE o SentencePiece) y que a menudo llevan el espacio delante pegado. Cada token tiene un número. El modelo recibe la lista de números y devuelve un logit (una puntuación) por cada token del vocabulario; se elige uno, se añade a la entrada y se repite. La respuesta se construye así, token a token.

Con el proyecto viene una clase Small_LLM_Model en el paquete llm_sdk con estos métodos públicos:

MétodoQué hace
get_logits_from_input_ids(input_ids)lista de IDs → logits del siguiente token
get_path_to_vocab_file()ruta del fichero de vocabulario (correspondencia ID ↔ token)
encode(text)texto → IDs con el tokenizador del modelo
decode(token_ids)IDs → texto (opcional)
Qué te obliga a aprender — A ver el modelo como lo que es: una función que va de una lista de enteros a una lista de números reales. Todo lo demás (elegir el máximo, parar, dar formato) lo decide el código que la rodea, y ese código es el tuyo. El fichero de vocabulario es la pieza clave, y el enunciado lo subraya: para saber qué tokens son válidos en cada paso necesitas saber qué texto representa cada uno.

04Constrained decoding

En cada paso, antes de elegir el token, el enunciado describe cuatro pasos:

  1. el modelo produce logits para todos los tokens;
  2. identificas qué tokens mantienen a la vez un JSON válido y conforme al esquema esperado;
  3. pones a menos infinito el logit de todos los demás;
  4. eliges solo entre los que quedan.

El paso 3, por sí solo, es una línea de numpy; lo que no se puede escribir en una línea es el paso 2, que es todo el proyecto:

logits[~permitidos] = -np.inf    # permitidos: array de bool, uno por token
siguiente = int(np.argmax(logits))

No basta con que el JSON sea sintácticamente correcto: si un argumento es de tipo number en el catálogo, en esa posición solo pueden entrar tokens que formen un número. Así el resultado se puede parsear siempre.

El enunciado avisa expresamente: la solución no puede depender de que el modelo produzca por sí solo JSON correcto a partir de un prompt con las definiciones. Eso no es fiable y no es lo que se evalúa.

Qué te obliga a aprender — Que la estructura vence al tamaño: con la guía adecuada, un modelo de unos 500 millones de parámetros se acerca en fiabilidad a modelos mucho mayores. Por debajo, es teoría de autómatas: en cada punto de la salida hay un conjunto de continuaciones legales (como en un autómata o una gramática), y la dificultad está en que los tokens no son caracteres sueltos, sino trozos de longitud variable que pueden cruzar fronteras (un token puede cerrar una comilla y abrir otra cosa). Y aparece una distinción que conviene tener clara: el modelo decide el contenido (qué función, qué valores) y tu decodificador decide la forma.

05Rendimiento, README y bonus

Objetivos que fija el enunciado:

El README (en inglés) lleva, además de las secciones habituales: explicación del algoritmo de constrained decoding, decisiones de diseño, análisis de rendimiento, dificultades encontradas, estrategia de pruebas y ejemplos de uso.

Bonus (solo si la obligatoria es perfecta): soportar más modelos, reescribir el tokenizador usando solo get_logits_from_input_ids y get_path_to_vocab_file en lugar de encode/decode, recuperación de errores avanzada, optimizaciones (caché, lotes), una batería de tests, visualizar el proceso de generación y soportar argumentos anidados complejos.

Puntos delicados

Fuente

El enunciado no está aún en el pack. Esta ficha sale de dos transcripciones públicas del enunciado en inglés (una indica versión 1.7), que coinciden en requisitos, formato y objetivos:

Para el trasfondo: el modelo es Qwen3-0.6B en Hugging Face. No confirmado: si se hace individual o en grupo, y las horas estimadas.