Secuencias de parada
En esta página
Detener la generación en el momento adecuado
Por defecto, el modelo se detiene solo por dos motivos: decide que ha terminado su respuesta y emite su token de fin, o alcanza el límite de max_tokens. Estos dos criterios no cubren todos los casos de uso. A veces querrás que la generación se detenga en un punto que solo tú conoces: justo antes de la siguiente sección de un documento, inmediatamente después de que se cierre un bloque JSON, o tan pronto como el modelo empiece a añadir comentarios que no necesitas.
Las secuencias de parada añaden este tercer criterio: en cuanto el modelo produce una secuencia de texto que hayas designado, la generación se detiene de inmediato. Piensa en ello como una herramienta de corte precisa, el complemento natural de las instrucciones de formato de tu mensaje de sistema, que el modelo sigue bien pero no siempre a la perfección.
Cómo funciona el parámetro stop
El parámetro acepta una lista de cadenas. La primera que aparezca en la salida pone fin a la generación:
from mistralai.client import Mistral
import os
client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))
response = client.chat.complete(
model="mistral-large-latest",
messages=[
{"role": "user", "content": "List the 10 largest cities in France."}
],
stop=["6."] # Stop after the first 5
)
print(response.choices[0].message.content)
# 1. Paris
# 2. Marseille
# 3. Lyon
# 4. Toulouse
# 5. Nice
Dos comportamientos destacan en este ejemplo. La secuencia de parada no se incluye en la respuesta: obtienes el texto que la precede, sin necesidad de limpieza por tu parte. Además, el finish_reason es "stop", exactamente igual que con una parada natural; la API no distingue entre ambas, así que depende de ti recordar qué solicitaste.
Tres casos de uso típicos
El primer caso gestiona al modelo parlanchín. Le pides una capital y te da la capital más tres frases de explicación que tu interfaz no esperaba. El mensaje de sistema establece la intención; las secuencias de parada la hacen cumplir:
response = client.chat.complete(
model="mistral-large-latest",
messages=[
{
"role": "system",
"content": "Answer with only the city name, nothing else."
},
{
"role": "user",
"content": "What is the capital of Italy?"
}
],
stop=["\n", ".", "Explanation"] # Stop at the first newline or period
)
print(response.choices[0].message.content.strip())
# Rome
El segundo caso cubre la generación de documentos sección por sección, cuando quieres mantener el control entre partes en lugar de dejar que el modelo produzca un informe entero de una sola vez. Te detienes en los delimitadores que señalan lo que viene a continuación:
response = client.chat.complete(
model="mistral-large-latest",
messages=[
{
"role": "system",
"content": "Write the Introduction section of a report."
},
{
"role": "user",
"content": "Topic: the impact of AI on employment in Europe."
}
],
stop=["## ", "---", "Conclusion"] # Stop before the next section
)
El tercer caso es el más rentable en la práctica: extraer JSON utilizable sin un paso de limpieza. Los modelos tienen la tendencia a envolver su salida en texto explicativo, lo cual rompe json.loads(); cortar en un doble salto de línea o en tres comillas invertidas elimina el problema desde la raíz.
response = client.chat.complete(
model="mistral-large-latest",
messages=[
{
"role": "system",
"content": "Respond only with valid JSON."
},
{
"role": "user",
"content": "Give me info for Paris: population, country, time zone."
}
],
stop=["\n\n", "```"] # Stop after the JSON block
)
Combinar secuencias de parada y streaming
Nada impide combinar ambos mecanismos: el flujo se detiene en cuanto se detecta una de las secuencias de parada en el texto generado, y los fragmentos que ya hayas recibido siguen siendo válidos.
stream = client.chat.stream(
model="mistral-large-latest",
messages=[
{"role": "user", "content": "Tell a short story."}
],
stop=["Fin.", "THE END", "---"]
)
full_text = ""
for chunk in stream:
content = chunk.data.choices[0].delta.content
if content:
full_text += content
print(content, end="", flush=True)
print(f"\n\nText: {len(full_text)} characters")
Limitaciones del mecanismo
Cuatro restricciones gobiernan el uso del parámetro stop. Puedes proporcionar como máximo cuatro secuencias por solicitud, lo que te obliga a elegir las más discriminativas en lugar de acumularlas. Distinguen entre mayúsculas y minúsculas: "end" nunca captará "End", así que debes tener en cuenta las variantes relevantes. La secuencia nunca se incluye en la respuesta, algo importante si el formato esperado termina con ese delimitador. Por último, la detección ocurre token a token: si tu secuencia cae en medio de un token, pasará desapercibida; otra razón para elegir delimitadores de varios caracteres en lugar de un único símbolo.
Errores costosos
El error más común es una secuencia demasiado corta, que provoca paradas prematuras. Un punto solo detiene la generación en la primera frase que ve, incluso en medio de una abreviatura; el error simétrico es elegir una cadena que el modelo nunca producirá, en cuyo caso el parámetro no hace nada y crees erróneamente que has establecido una barrera de seguridad.
# BAD: sequence too short, premature stops
stop=["."] # Stops at every sentence!
# GOOD: context-specific sequence
stop=[".\n\n"] # Stops after a period followed by a double newline
# BAD: sequence the model will never produce
stop=["XYZZY"] # Has no effect
# GOOD: realistic sequence based on expected format
stop=["Next question:", "---"]
La regla que se deduce de estas cuatro líneas es simple: una buena secuencia de parada deriva del formato que has pedido al modelo, nunca de tu imaginación.
Ejemplo completo: preguntas y respuestas controladas
Vamos a ensamblar estos elementos en una función breve de preguntas y respuestas, donde una temperatura baja garantiza estabilidad factual, max_tokens establece un techo de seguridad y las secuencias de parada eliminan los comentarios que el modelo podría verse tentado a añadir tras su respuesta:
from mistralai.client import Mistral
import os
client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))
def ask_single_question(question: str) -> str:
"""Ask a question and get a concise answer without chatter."""
response = client.chat.complete(
model="mistral-large-latest",
messages=[
{
"role": "system",
"content": "Answer in a single sentence, directly and factually."
},
{"role": "user", "content": question}
],
max_tokens=100,
stop=["\n\n", "Remark:", "Note:"],
temperature=0.1
)
return response.choices[0].message.content.strip()
# Test
questions = [
"What is the speed of light?",
"Who invented the telephone?",
"How many planets are in the solar system?"
]
for q in questions:
print(f"Q: {q}")
print(f"A: {ask_single_question(q)}\n")
Ejecuta este script una vez tal cual está y una segunda vez tras eliminar el parámetro stop: comparar las dos salidas te mostrará exactamente qué filtran esas tres secuencias.
Puntos clave
- Las secuencias de parada detienen la generación cuando el modelo produce texto específico
- Máximo de 4 secuencias por solicitud; distinguen entre mayúsculas y minúsculas
- La secuencia de parada nunca se incluye en la respuesta
- Usa secuencias lo suficientemente específicas para evitar paradas prematuras
- Compatible con streaming y todos los demás parámetros