DSPy vs. LangGraph: AI Agent Frameworks Explained | Stanford CS329Z Lecture 5 with Michael Ryan

DSPy is built around three core ideas: signatures, which define the inputs and outputs for language models; modules, which define how inference is performed on these signatures; and optimizers, which automatically improve prompts and weights.

DSPy uses adapters that convert signatures into prompts designed to enforce specific formats, like JSON. DSPy then validates the model's output against this format.

Yes, DSPy supports defining complex type signatures, including literals and optional fields (string or None). It also allows hints for formatting, like specifying a 24-hour clock.

DSPy optimizers automatically refine prompts based on data and metrics. They can iterate through various prompt versions, testing them against evaluations to find the most effective one, even if the resulting prompt seems unconventional.

DSPy focuses on optimizing prompts and defining clear input/output contracts for LLMs, often with Python-based control flow. LangGraph excels at orchestrating complex workflows through a graph structure with shared state, nodes, and edges, making it suitable for distributed computing and robust state management.

Yes, in LangGraph, nodes represent free-form code, allowing you to assign different language models or even multiple LLMs within a single node.

Agent harnesses are pre-built frameworks that provide the infrastructure around an LLM to make an agent functional. They handle aspects like tool provision, memory management, context handling, and tool execution.

As LLMs tackle longer and more complex tasks, agents run for extended periods. Orchestration tools like Temporal ensure reliability and prevent failures, while telemetry and observability frameworks are crucial for debugging and monitoring these long-running processes.

Best practices include keeping systems simple (workflows might suffice over agents), carefully selecting tools, designing for failure and recovery, running rigorous evaluations grounded in custom domains, and fully understanding the system's underlying mechanics.

Reliability can be enhanced by designing for failure with observable and recoverable mechanisms, using tools like Temporal for retries and state management, setting timeouts and execution budgets, and continuously monitoring system state.

Frameworks abstract away complexity, like PyTorch abstracting backpropagation. While useful, understanding the underlying details allows for building better, more robust systems and diagnosing failures effectively, which is the goal of this course.