De los prompts a los productos: el nuevo stack de producción

Stack clásico (2023)

Explícito, predecible, controlable. Pero: rígido, lento, se rompe con bordes no previstos.

Stack agéntico (2025)

Dinámico, tolera ambigüedad. Pero: probabilista, depura distinto, el coste por token importa a escala.

Enfoque clásico (Flask + Elasticsearch)

@app.route('/api/query', methods=['POST'])
    def handle_query():
        user_query = request.json['query']
    
        # Entity extraction
        entities = ner_model.extract(user_query)
    
        # Build Elasticsearch query
        es_query = {
            "bool": {
                "must": [{"match": {"content": user_query}}],
                "should": [{"terms": {"entities": entities}}]
            }
        }
    
        # Search
        results = es.search(index="knowledge_base", body=es_query)
    
        # Rank results
        ranked = rank_by_relevance(results, entities)
    
        # Generate response from template
        if not ranked:
            return {"answer": "No results found"}
    
        top_result = ranked[0]
        answer = f"Based on {top_result['title']}: {top_result['summary']}"
    
        return {"answer": answer, "sources": ranked[:3]}
    

Rígido, paso a paso explícito, se tuerce con preguntas poco “esperadas”.

Enfoque agéntico (LangGraph + pgvector)

from langgraph.graph import StateGraph, START, END
    from langchain_openai import ChatOpenAI
    from typing_extensions import TypedDict
    
    # Define state schema
    class State(TypedDict):
        query: str
        context: str
        answer: str
    
    # Retrieval function using vector store
    def retrieve(state: State) -> dict:
        docs = vector_store.similarity_search(state["query"], k=5)
        return {"context": docs}
    
    def synthesize(state: State) -> dict:
        response = llm.invoke(f"""
            Context: {state["context"]}
            Question: {state["query"]}
            Provide a concise answer with citations.
        """)
        return {"answer": response}
    
    # Build the graph
    workflow = StateGraph(State)
    workflow.add_node("retrieve", retrieve)
    workflow.add_node("synthesize", synthesize)
    
    workflow.add_edge(START, "retrieve")
    workflow.add_edge("retrieve", "synthesize")
    workflow.add_edge("synthesize", END)
    
    # That's it. Handles variations, follow-ups, clarifications.
    agent = workflow.compile()
    response = agent.invoke({"query": user_input})
    

Describe qué (recupera, sintetiza), no todas las ramas. Se adapta mejor a intención; sigue haciendo falta observar y afinar.