stanfordnlp/dspy

Features

• Declarative AI Frameworks - Specifies desired model behaviors using high-level declarations that translate intent into executable instructions.
• Agentic Orchestration Frameworks - Organizes complex AI workflows into nested, reusable objects that manage state and execution flow independently.
• AI Signature Definitions - Creates signatures using classes and docstrings to provide detailed instructional context.
• Automated Prompt Engineering - Improves program instructions by using a reflection loop that evaluates candidates and proposes iterative improvements.
• Automated Prompt Optimization - Systematically improves model performance by iteratively refining instructions and few-shot examples using evaluation metrics.
• Declarative AI Programming - Defines task logic through modular, typed schemas to build complex language model applications.
• Declarative Task Signatures - Defines task logic and data flow requirements through declarative, typed class schemas.
• Agentic Orchestration Modules - dspy.Module(callbacks=None) Bases: BaseModule Base class for all DSPy modules (programs). A Module is a building block for DSPy programs that can contain predictors, sub-modules, and custom logic. Modules can be c
• Agentic Reasoning Loops - Executes iterative reasoning loops that allow models to synthesize information and call tools until a task is resolved.
• Few-Shot Learning Optimizers - Selects the best set of few-shot demonstrations by running multiple bootstrap rounds and evaluating performance.
• Iterative Program Optimization - Improves task reasoning and execution efficiency by applying prompt and weight adjustments in sequence.
• Optimization Engines - Provides a computational layer that iteratively refines instructions and demonstrations based on feedback.
• Agentic Workflow Orchestration - Constructs autonomous reasoning loops that integrate language models with external tools and APIs.
• Composable Agentic Architectures - Enables the construction of complex reasoning loops through hierarchical, reusable Python objects.
• Predictor Modules - Maps inputs to outputs using a language model as the fundamental prediction unit.
• Prompt Optimization Strategies - Improves prediction quality by generating feedback on failed attempts and injecting that advice into subsequent runs.
• Signature Interfaces - Translates task signatures into model-specific prompts and parses responses into structured types for consistent communication.
• Structured Data Coercion - Automatically coerces and validates language model outputs into structured, typed data formats.
• Modular Program Composition - Assembles complex software systems by combining independent, reusable functional units.
• LLM Evaluation - Measures output quality using custom metrics and model-based judges to ensure consistent behavior across pipelines.
• Chain-of-Thought Modules - Implements modules that reason step by step to improve performance on complex tasks.
• Demonstration Bootstrapping - Creates few-shot examples by running a teacher model on training data and filtering successful traces.
• Few-Shot Optimizers - Automatically selects and filters successful traces to populate demonstration slots for improved model performance.
• Modular AI Pipelines - Assembles sophisticated AI systems from reusable, hierarchical components that manage state and execution flow.
• Module Composition - Builds complex logic by subclassing base modules and piping inputs through sub-modules.
• Tool Integration Interfaces - Wraps Python functions as tools that language models can invoke to perform specific tasks.
• Tool-Using Agents - Enables language models to interact with external tools and functions through reasoning and acting loops.
• Agent Frameworks - Framework for programming LLMs with automatic prompt and weight optimization.
• Agentic Frameworks - Framework for programmatically optimizing prompts and model weights.
• AI and Agents - A framework for programming, not prompting, language models.
• Application Development - Framework for programming foundation models instead of prompting.
• Language Model Development - Framework for programmatic interaction with foundation models.
• LLM Development Utilities - Framework for programming foundation models instead of prompting.
• LLM Frameworks - Framework for programming foundation models instead of manual prompting.
• LLM Frameworks and Libraries - Framework for programmatic control of foundation models.
• Prompt Engineering - Framework for programming language models instead of manual prompting.
• Prompt Engineering Frameworks - Declarative framework for optimizing LM pipelines and few-shot demonstrations.
• Prompt Engineering Tools - Framework for programming foundation models instead of prompting.
• Prompt Optimization - Compiling declarative programs into optimized language model pipelines.
• Prompt Optimization Tools - Provides multiple optimizers for automatic prompt and weight tuning.
• RAG Frameworks - Compiles declarative language model calls into self-improving pipelines.
• Retrieval Augmented Generation - Listed in the “Retrieval Augmented Generation” section of the Llm Course awesome list.
• Prompt Engineering - Framework for programmatically optimizing prompts and model performance.
• Prompt Optimization Tools - Systematic framework for optimizing prompts and model parameters.
• Agentic AI - Listed in the “Agentic AI” section of the The Incredible Pytorch awesome list.
• Code Execution Agents - Utilizes code interpretation to solve problems through iterative reasoning and execution loops.
• Dynamic Demonstration Retrieval - Populates predictor demo slots dynamically at inference time using K-nearest neighbors.
• Inference Sampling Strategies - Generates multiple results and selects the best candidate based on custom reward functions.
• Program-of-Thought Modules - Solves problems by generating and executing Python programs within the reasoning loop.
• Structured Data Extraction - Converts unstructured model outputs into validated, typed data structures for reliable software integration.
• Structured Data Parsers - Enforces structured output formats by mapping model completions to defined Python types and validating them.
• Structured Model Interfaces - Maps model inputs and outputs onto validated data structures to ensure consistent communication.
• Formal Verification Tools - Validates data structures and function signatures at runtime to ensure consistent communication.
• Ensemble Modules - Runs modules multiple times with different rollouts to select the best output based on reward functions.
• Input Validation Schemas - Enforces strict field constraints and data consistency within language model interactions using typed schemas.
• Model Context Configuration - Assigns specific language models to different subtasks to ensure optimal model usage.
• Prompt Adapters - Provides automated transformation of inputs into structured prompts and parses model responses into consistent data formats.
• Refinement Modules - Iteratively refines module outputs by running them multiple times against reward functions.
• Model State Persistence - Saves optimized program states or module structures to disk for portability.
• Model State Restoration - Restores optimized instructions and metadata by loading saved program states back into class instances.
• Model Evaluation - Enables the creation of custom functions to measure program success and guide optimization.

Star history