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.
{"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).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:
numpy y json;Qwen/Qwen3-0.6B; se pueden usar otros siempre que
funcione con ese;llm_sdk que viene
con el enunciado;uv; quien evalúe (y la moulinette) solo ejecutará
uv sync;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).
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é.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:
function_calling_tests.json: un array de objetos
{"prompt": "..."} (en el ejemplo: sumar dos números, saludar a alguien, invertir
una cadena…);functions_definition.json: el catálogo de funciones, cada una con
name, description, parameters (nombre y tipo de cada
argumento) y returns.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.
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étodo | Qué 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) |
En cada paso, antes de elegir el token, el enunciado describe cuatro pasos:
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.
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.
{", otro
name, otro ":; y muchos llevan un espacio delante. Comprobar si un
token «encaja» exige mirar todo su texto, no solo el primer carácter.2.0 para un argumento
number. Hay que decidir cómo se representan y cuándo se termina un número (el
modelo podría querer seguir poniendo dígitos para siempre).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.