En el corazón de cada agente de IA exitoso se encuentra una habilidad esencial: incitación (o “ingeniería rápida”). Es el método de instruir a los LLM para realizar tareas diseñando cuidadosamente el texto de entrada.
La ingeniería rápida es la evolución de las entradas para el primero Modelos NLP de texto a texto (2018). En ese momento, los desarrolladores generalmente se centraron más en el lado del modelado y la ingeniería de características. Después de la creación de grandes modelos GPT (2022), todos comenzamos a usar principalmente herramientas previamente capacitadas, por lo que el enfoque ha cambiado en el formato de entrada. Por lo tanto, el Disciplina de “ingeniería rápida” nació, y ahora (2025) ha madurado en una mezcla de arte y ciencia, ya que la PNL está difuminando la línea entre el código y el aviso.
Los diferentes tipos de técnicas de solicitación crean diferentes tipos de agentes. Cada método mejora una habilidad específica: lógica, planificación, memoria, precisión e integración de herramientas. Veamos a todos con un ejemplo muy simple.
## setup
import ollama
llm = "qwen2.5"
## question
q = "What is 30 multiplied by 10?"Técnicas principales
1) “Indicación regular “ – Simplemente haga una pregunta y obtenga una respuesta directa. También se llama “disparo cero” específicamente cuando el modelo recibe una tarea sin ningún ejemplo previo de cómo resolverlo. Esta técnica básica está diseñada para Agentes de un solo paso que ejecuta la tarea sin razonamiento intermedio, especialmente modelos tempranos.
response = ollama.chat(model=llm, messages=[
{'role':'user', 'content':q}
])
print(response['message']['content'])
2) Reaccionar (Razón+ACT) – Una combinación de razonamiento y acción. El modelo no solo piensa a través de un problema, sino que también toma medidas basadas en su razonamiento. Por lo tanto, es más interactivo ya que el modelo alterna entre pasos y acciones de razonamiento, refinando su enfoque iterativamente. Básicamente, es un bucle de observación de acción pensada. Utilizado para tareas más complicadascomo buscar en la web y tomar decisiones basadas en los hallazgos, y generalmente diseñado para Agentes de varios pasos que realizan una serie de pasos de razonamiento y acciones para llegar a un resultado final. Pueden dividir tareas complejas en partes más pequeñas y más manejables que se construyen progresivamente entre sí.
Personalmente, me gustan mucho los agentes React, ya que los encuentro más similares a los humanos porque se “joden y descubren” como nosotros.
prompt = '''
To solve the task, you must plan forward to proceed in a series of steps, in a cycle of 'Thought:', 'Action:', and 'Observation:' sequences.
At each step, in the 'Thought:' sequence, you should first explain your reasoning towards solving the task, then the tools that you want to use.
Then in the 'Action:' sequence, you shold use one of your tools.
During each intermediate step, you can use 'Observation:' field to save whatever important information you will use as input for the next step.
'''
response = ollama.chat(model=llm, messages=[
{'role':'user', 'content':q+" "+prompt}
])
print(response['message']['content'])3) Cadena de pensamiento (cot) – Un patrón de razonamiento que implica generar el proceso para llegar a una conclusión. El modelo se presiona para “pensar en voz alta” presentando explícitamente los pasos lógicos que conducen a la respuesta final. Básicamente, es un plan sin comentarios. La cuna es la más utilizada para tareas avanzadascomo resolver un problema matemático que podría necesitar razonamiento paso a paso, y generalmente diseñado para Agentes de varios pasos.
prompt = '''Let’s think step by step.'''
response = ollama.chat(model=llm, messages=[
{'role':'user', 'content':q+" "+prompt}
])
print(response['message']['content'])Extensiones de cuna
De la cadena de técnica derivó varios otros enfoques de indicación nuevos.
4) Indicación de reflexión Eso agrega una fase iterativa de autoevaluación o autocorrección además del razonamiento inicial de COT, donde el modelo revisa y critica sus propios resultados (detectar errores, identificar brechas, sugerir mejoras).
cot_answer = response['message']['content']
response = ollama.chat(model=llm, messages=[
{'role':'user', 'content': f'''Here was your original answer:\n\n{cot_answer}\n\n
Now reflect on whether it was correct or if it was the best approach.
If not, correct your reasoning and answer.'''}
])
print(response['message']['content'])5) Árbol de pensamientos (Tot) Eso generaliza la cuna en un árbol, explorando múltiples cadenas de razonamiento simultáneamente.
num_branches = 3
prompt = f'''
You will think of multiple reasoning paths (thought branches). For each path, write your reasoning and final answer.
After exploring {num_branches} different thoughts, pick the best final answer and explain why.
'''
response = ollama.chat(model=llm, messages=[
{'role':'user', 'content': f"Task: {q} \n{prompt}"}
])
print(response['message']['content'])6) Gráfico de pensamientos (Got) Eso generaliza la cuna en un gráfico, considerando también ramas interconectadas.
class GoT:
def __init__(self, question):
self.question = question
self.nodes = {} # node_id: text
self.edges = [] # (from_node, to_node, relation)
self.counter = 1
def add_node(self, text):
node_id = f"Thought{self.counter}"
self.nodes[node_id] = text
self.counter += 1
return node_id
def add_edge(self, from_node, to_node, relation):
self.edges.append((from_node, to_node, relation))
def show(self):
print("\n--- Current Thoughts ---")
for node_id, text in self.nodes.items():
print(f"{node_id}: {text}\n")
print("--- Connections ---")
for f, t, r in self.edges:
print(f"{f} --[{r}]--> {t}")
print("\n")
def expand_thought(self, node_id):
prompt = f"""
You are reasoning about the task: {self.question}
Here is a previous thought node ({node_id}):\"\"\"{self.nodes[node_id]}\"\"\"
Please provide a refinement, an alternative viewpoint, or a related thought that connects to this node.
Label your new thought clearly, and explain its relation to the previous one.
"""
response = ollama.chat(model=llm, messages=[{'role':'user', 'content':prompt}])
return response['message']['content']
## Start Graph
g = GoT(q)
## Get initial thought
response = ollama.chat(model=llm, messages=[
{'role':'user', 'content':q}
])
n1 = g.add_node(response['message']['content'])
## Expand initial thought with some refinements
refinements = 1
for _ in range(refinements):
expansion = g.expand_thought(n1)
n_new = g.add_node(expansion)
g.add_edge(n1, n_new, "expansion")
g.show()
## Final Answer
prompt = f'''
Here are the reasoning thoughts so far:
{chr(10).join([f"{k}: {v}" for k,v in g.nodes.items()])}
Based on these, select the best reasoning and final answer for the task: {q}
Explain your choice.
'''
response = ollama.chat(model=llm, messages=[
{'role':'user', 'content':q}
])
print(response['message']['content'])7) Programa de pensamientos (Pot) Eso se especializa en programación, donde el razonamiento ocurre a través de fragmentos de código ejecutable.
import re
def extract_python_code(text):
match = re.search(r"```python(.*?)```", text, re.DOTALL)
if match:
return match.group(1).strip()
return None
def sandbox_exec(code):
## Create a minimal sandbox with safety limitation
allowed_builtins = {'abs', 'min', 'max', 'pow', 'round'}
safe_globals = {k: __builtins__.__dict__[k] for k in allowed_builtins if k in __builtins__.__dict__}
safe_locals = {}
exec(code, safe_globals, safe_locals)
return safe_locals.get('result', None)
prompt = '''
Write a short Python program that calculates the answer and assigns it to a variable named 'result'.
Return only the code enclosed in triple backticks with 'python' (```python ... ```).
'''
response = ollama.chat(model=llm, messages=[
{'role':'user', 'content': f"Task: {q} \n{prompt}"}
])
print(response['message']['content'])
sandbox_exec(code=extract_python_code(text=response['message']['content']))Conclusión
Este artículo ha sido un tutorial para Recapitulación de todas las principales técnicas de indicación para los agentes de IA. No hay una sola “mejor” técnica de incorporación, ya que depende en gran medida de la tarea y la complejidad del razonamiento necesario.
Por ejemplo, tareas simples, como resumen y traducciónson realizados con una solicitud de disparo cero/regular, mientras que la cuna funciona bien para matemáticas y lógica tareas. Por otro lado, Agentes con herramientas se crean típicamente con el modo React. Además, la reflexión es más apropiada cuando aprender de los errores o iteraciones mejora los resultados, como juego de azar.
En términos de versatilidad para tareas complejas, Pot es el verdadero ganador porque se basa únicamente en la generación y ejecución de código. De hecho, los agentes de la olla se están acercando a reemplazar a los humanos En varios taks de oficina.
Creo que, en el futuro cercano, la provisión no se tratará solo de “lo que le dices al modelo”, sino de orquestar un bucle interactivo entre la intención humana, el razonamiento de la máquina y la acción externa.
Código completo para este artículo: Github
¡Espero que lo hayas disfrutado! No dude en ponerse en contacto conmigo para obtener preguntas y comentarios o simplemente para compartir sus interesantes proyectos.
(Todas las imágenes son del autor a menos que lo contrario anotado)