[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M7D2R4MSWH2S1HJRH8011AHD":3,"skill-same:01M7D2R4MSWH2S1HJRH8011AHD":73},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":15,"categories":16,"keywords":17,"publishedAt":18,"linkOnly":19,"markdownContent":20,"markdownBody":21,"frontMatter":22,"refName":39,"commitSha":40,"skillDirectory":41,"forksCount":13,"repositoryHtmlUrl":42,"repositoryHomepageUrl":6,"ownerHtmlUrl":43,"ownerBlogUrl":6,"ownerDescription":6,"updatedAt":44,"install":45,"resources":58},"01M7D2R4MSWH2S1HJRH8011AHD","dspy",null,"Build complex AI systems with declarative programming, optimize prompts automatically, create modular RAG systems and agents with DSPy - Stanford NLP's framework for systematic LM programming","beyondai\u002Fsandbox","beyondai","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F2845958?v=4","01M7D24SBNM47BJGJ9J2HB13BP","01M7D24SCDC9DYE005XH6R553S",0,"MIT","https:\u002F\u002Fgithub.com\u002Fbeyondai\u002Fsandbox\u002Fblob\u002Fmain\u002Flabs\u002F.codex\u002Fskills\u002Fdspy\u002FSKILL.md",[],[],"2026-11-15 14:19:17",false,"---\nname: dspy\ndescription: Build complex AI systems with declarative programming, optimize prompts automatically, create modular RAG systems and agents with DSPy - Stanford NLP's framework for systematic LM programming\nversion: 1.0.0\nauthor: Orchestra Research\nlicense: MIT\ntags: [Prompt Engineering, DSPy, Declarative Programming, RAG, Agents, Prompt Optimization, LM Programming, Stanford NLP, Automatic Optimization, Modular AI]\ndependencies: [dspy, openai, anthropic]\n---\n\n# DSPy: Declarative Language Model Programming\n\n## When to Use This Skill\n\nUse DSPy when you need to:\n- **Build complex AI systems** with multiple components and workflows\n- **Program LMs declaratively** instead of manual prompt engineering\n- **Optimize prompts automatically** using data-driven methods\n- **Create modular AI pipelines** that are maintainable and portable\n- **Improve model outputs systematically** with optimizers\n- **Build RAG systems, agents, or classifiers** with better reliability\n\n**GitHub Stars**: 22,000+ | **Created By**: Stanford NLP\n\n## Installation\n\n```bash\n# Stable release\npip install dspy\n\n# Latest development version\npip install git+https:\u002F\u002Fgithub.com\u002Fstanfordnlp\u002Fdspy.git\n\n# With specific LM providers\npip install dspy[openai]        # OpenAI\npip install dspy[anthropic]     # Anthropic Claude\npip install dspy[all]           # All providers\n```\n\n## Quick Start\n\n### Basic Example: Question Answering\n\n```python\nimport dspy\n\n# Configure your language model\nlm = dspy.Claude(model=\"claude-sonnet-4-5-20250929\")\ndspy.settings.configure(lm=lm)\n\n# Define a signature (input → output)\nclass QA(dspy.Signature):\n    \"\"\"Answer questions with short factual answers.\"\"\"\n    question = dspy.InputField()\n    answer = dspy.OutputField(desc=\"often between 1 and 5 words\")\n\n# Create a module\nqa = dspy.Predict(QA)\n\n# Use it\nresponse = qa(question=\"What is the capital of France?\")\nprint(response.answer)  # \"Paris\"\n```\n\n### Chain of Thought Reasoning\n\n```python\nimport dspy\n\nlm = dspy.Claude(model=\"claude-sonnet-4-5-20250929\")\ndspy.settings.configure(lm=lm)\n\n# Use ChainOfThought for better reasoning\nclass MathProblem(dspy.Signature):\n    \"\"\"Solve math word problems.\"\"\"\n    problem = dspy.InputField()\n    answer = dspy.OutputField(desc=\"numerical answer\")\n\n# ChainOfThought generates reasoning steps automatically\ncot = dspy.ChainOfThought(MathProblem)\n\nresponse = cot(problem=\"If John has 5 apples and gives 2 to Mary, how many does he have?\")\nprint(response.rationale)  # Shows reasoning steps\nprint(response.answer)     # \"3\"\n```\n\n## Core Concepts\n\n### 1. Signatures\n\nSignatures define the structure of your AI task (inputs → outputs):\n\n```python\n# Inline signature (simple)\nqa = dspy.Predict(\"question -> answer\")\n\n# Class signature (detailed)\nclass Summarize(dspy.Signature):\n    \"\"\"Summarize text into key points.\"\"\"\n    text = dspy.InputField()\n    summary = dspy.OutputField(desc=\"bullet points, 3-5 items\")\n\nsummarizer = dspy.ChainOfThought(Summarize)\n```\n\n**When to use each:**\n- **Inline**: Quick prototyping, simple tasks\n- **Class**: Complex tasks, type hints, better documentation\n\n### 2. Modules\n\nModules are reusable components that transform inputs to outputs:\n\n#### dspy.Predict\nBasic prediction module:\n\n```python\npredictor = dspy.Predict(\"context, question -> answer\")\nresult = predictor(context=\"Paris is the capital of France\",\n                   question=\"What is the capital?\")\n```\n\n#### dspy.ChainOfThought\nGenerates reasoning steps before answering:\n\n```python\ncot = dspy.ChainOfThought(\"question -> answer\")\nresult = cot(question=\"Why is the sky blue?\")\nprint(result.rationale)  # Reasoning steps\nprint(result.answer)     # Final answer\n```\n\n#### dspy.ReAct\nAgent-like reasoning with tools:\n\n```python\nfrom dspy.predict import ReAct\n\nclass SearchQA(dspy.Signature):\n    \"\"\"Answer questions using search.\"\"\"\n    question = dspy.InputField()\n    answer = dspy.OutputField()\n\ndef search_tool(query: str) -> str:\n    \"\"\"Search Wikipedia.\"\"\"\n    # Your search implementation\n    return results\n\nreact = ReAct(SearchQA, tools=[search_tool])\nresult = react(question=\"When was Python created?\")\n```\n\n#### dspy.ProgramOfThought\nGenerates and executes code for reasoning:\n\n```python\npot = dspy.ProgramOfThought(\"question -> answer\")\nresult = pot(question=\"What is 15% of 240?\")\n# Generates: answer = 240 * 0.15\n```\n\n### 3. Optimizers\n\nOptimizers improve your modules automatically using training data:\n\n#### BootstrapFewShot\nLearns from examples:\n\n```python\nfrom dspy.teleprompt import BootstrapFewShot\n\n# Training data\ntrainset = [\n    dspy.Example(question=\"What is 2+2?\", answer=\"4\").with_inputs(\"question\"),\n    dspy.Example(question=\"What is 3+5?\", answer=\"8\").with_inputs(\"question\"),\n]\n\n# Define metric\ndef validate_answer(example, pred, trace=None):\n    return example.answer == pred.answer\n\n# Optimize\noptimizer = BootstrapFewShot(metric=validate_answer, max_bootstrapped_demos=3)\noptimized_qa = optimizer.compile(qa, trainset=trainset)\n\n# Now optimized_qa performs better!\n```\n\n#### MIPRO (Most Important Prompt Optimization)\nIteratively improves prompts:\n\n```python\nfrom dspy.teleprompt import MIPRO\n\noptimizer = MIPRO(\n    metric=validate_answer,\n    num_candidates=10,\n    init_temperature=1.0\n)\n\noptimized_cot = optimizer.compile(\n    cot,\n    trainset=trainset,\n    num_trials=100\n)\n```\n\n#### BootstrapFinetune\nCreates datasets for model fine-tuning:\n\n```python\nfrom dspy.teleprompt import BootstrapFinetune\n\noptimizer = BootstrapFinetune(metric=validate_answer)\noptimized_module = optimizer.compile(qa, trainset=trainset)\n\n# Exports training data for fine-tuning\n```\n\n### 4. Building Complex Systems\n\n#### Multi-Stage Pipeline\n\n```python\nimport dspy\n\nclass MultiHopQA(dspy.Module):\n    def __init__(self):\n        super().__init__()\n        self.retrieve = dspy.Retrieve(k=3)\n        self.generate_query = dspy.ChainOfThought(\"question -> search_query\")\n        self.generate_answer = dspy.ChainOfThought(\"context, question -> answer\")\n\n    def forward(self, question):\n        # Stage 1: Generate search query\n        search_query = self.generate_query(question=question).search_query\n\n        # Stage 2: Retrieve context\n        passages = self.retrieve(search_query).passages\n        context = \"\\n\".join(passages)\n\n        # Stage 3: Generate answer\n        answer = self.generate_answer(context=context, question=question).answer\n        return dspy.Prediction(answer=answer, context=context)\n\n# Use the pipeline\nqa_system = MultiHopQA()\nresult = qa_system(question=\"Who wrote the book that inspired the movie Blade Runner?\")\n```\n\n#### RAG System with Optimization\n\n```python\nimport dspy\nfrom dspy.retrieve.chromadb_rm import ChromadbRM\n\n# Configure retriever\nretriever = ChromadbRM(\n    collection_name=\"documents\",\n    persist_directory=\".\u002Fchroma_db\"\n)\n\nclass RAG(dspy.Module):\n    def __init__(self, num_passages=3):\n        super().__init__()\n        self.retrieve = dspy.Retrieve(k=num_passages)\n        self.generate = dspy.ChainOfThought(\"context, question -> answer\")\n\n    def forward(self, question):\n        context = self.retrieve(question).passages\n        return self.generate(context=context, question=question)\n\n# Create and optimize\nrag = RAG()\n\n# Optimize with training data\nfrom dspy.teleprompt import BootstrapFewShot\n\noptimizer = BootstrapFewShot(metric=validate_answer)\noptimized_rag = optimizer.compile(rag, trainset=trainset)\n```\n\n## LM Provider Configuration\n\n### Anthropic Claude\n\n```python\nimport dspy\n\nlm = dspy.Claude(\n    model=\"claude-sonnet-4-5-20250929\",\n    api_key=\"your-api-key\",  # Or set ANTHROPIC_API_KEY env var\n    max_tokens=1000,\n    temperature=0.7\n)\ndspy.settings.configure(lm=lm)\n```\n\n### OpenAI\n\n```python\nlm = dspy.OpenAI(\n    model=\"gpt-4\",\n    api_key=\"your-api-key\",\n    max_tokens=1000\n)\ndspy.settings.configure(lm=lm)\n```\n\n### Local Models (Ollama)\n\n```python\nlm = dspy.OllamaLocal(\n    model=\"llama3.1\",\n    base_url=\"http:\u002F\u002Flocalhost:11434\"\n)\ndspy.settings.configure(lm=lm)\n```\n\n### Multiple Models\n\n```python\n# Different models for different tasks\ncheap_lm = dspy.OpenAI(model=\"gpt-3.5-turbo\")\nstrong_lm = dspy.Claude(model=\"claude-sonnet-4-5-20250929\")\n\n# Use cheap model for retrieval, strong model for reasoning\nwith dspy.settings.context(lm=cheap_lm):\n    context = retriever(question)\n\nwith dspy.settings.context(lm=strong_lm):\n    answer = generator(context=context, question=question)\n```\n\n## Common Patterns\n\n### Pattern 1: Structured Output\n\n```python\nfrom pydantic import BaseModel, Field\n\nclass PersonInfo(BaseModel):\n    name: str = Field(description=\"Full name\")\n    age: int = Field(description=\"Age in years\")\n    occupation: str = Field(description=\"Current job\")\n\nclass ExtractPerson(dspy.Signature):\n    \"\"\"Extract person information from text.\"\"\"\n    text = dspy.InputField()\n    person: PersonInfo = dspy.OutputField()\n\nextractor = dspy.TypedPredictor(ExtractPerson)\nresult = extractor(text=\"John Doe is a 35-year-old software engineer.\")\nprint(result.person.name)  # \"John Doe\"\nprint(result.person.age)   # 35\n```\n\n### Pattern 2: Assertion-Driven Optimization\n\n```python\nimport dspy\nfrom dspy.primitives.assertions import assert_transform_module, backtrack_handler\n\nclass MathQA(dspy.Module):\n    def __init__(self):\n        super().__init__()\n        self.solve = dspy.ChainOfThought(\"problem -> solution: float\")\n\n    def forward(self, problem):\n        solution = self.solve(problem=problem).solution\n\n        # Assert solution is numeric\n        dspy.Assert(\n            isinstance(float(solution), float),\n            \"Solution must be a number\",\n            backtrack=backtrack_handler\n        )\n\n        return dspy.Prediction(solution=solution)\n```\n\n### Pattern 3: Self-Consistency\n\n```python\nimport dspy\nfrom collections import Counter\n\nclass ConsistentQA(dspy.Module):\n    def __init__(self, num_samples=5):\n        super().__init__()\n        self.qa = dspy.ChainOfThought(\"question -> answer\")\n        self.num_samples = num_samples\n\n    def forward(self, question):\n        # Generate multiple answers\n        answers = []\n        for _ in range(self.num_samples):\n            result = self.qa(question=question)\n            answers.append(result.answer)\n\n        # Return most common answer\n        most_common = Counter(answers).most_common(1)[0][0]\n        return dspy.Prediction(answer=most_common)\n```\n\n### Pattern 4: Retrieval with Reranking\n\n```python\nclass RerankedRAG(dspy.Module):\n    def __init__(self):\n        super().__init__()\n        self.retrieve = dspy.Retrieve(k=10)\n        self.rerank = dspy.Predict(\"question, passage -> relevance_score: float\")\n        self.answer = dspy.ChainOfThought(\"context, question -> answer\")\n\n    def forward(self, question):\n        # Retrieve candidates\n        passages = self.retrieve(question).passages\n\n        # Rerank passages\n        scored = []\n        for passage in passages:\n            score = float(self.rerank(question=question, passage=passage).relevance_score)\n            scored.append((score, passage))\n\n        # Take top 3\n        top_passages = [p for _, p in sorted(scored, reverse=True)[:3]]\n        context = \"\\n\\n\".join(top_passages)\n\n        # Generate answer\n        return self.answer(context=context, question=question)\n```\n\n## Evaluation and Metrics\n\n### Custom Metrics\n\n```python\ndef exact_match(example, pred, trace=None):\n    \"\"\"Exact match metric.\"\"\"\n    return example.answer.lower() == pred.answer.lower()\n\ndef f1_score(example, pred, trace=None):\n    \"\"\"F1 score for text overlap.\"\"\"\n    pred_tokens = set(pred.answer.lower().split())\n    gold_tokens = set(example.answer.lower().split())\n\n    if not pred_tokens:\n        return 0.0\n\n    precision = len(pred_tokens & gold_tokens) \u002F len(pred_tokens)\n    recall = len(pred_tokens & gold_tokens) \u002F len(gold_tokens)\n\n    if precision + recall == 0:\n        return 0.0\n\n    return 2 * (precision * recall) \u002F (precision + recall)\n```\n\n### Evaluation\n\n```python\nfrom dspy.evaluate import Evaluate\n\n# Create evaluator\nevaluator = Evaluate(\n    devset=testset,\n    metric=exact_match,\n    num_threads=4,\n    display_progress=True\n)\n\n# Evaluate model\nscore = evaluator(qa_system)\nprint(f\"Accuracy: {score}\")\n\n# Compare optimized vs unoptimized\nscore_before = evaluator(qa)\nscore_after = evaluator(optimized_qa)\nprint(f\"Improvement: {score_after - score_before:.2%}\")\n```\n\n## Best Practices\n\n### 1. Start Simple, Iterate\n\n```python\n# Start with Predict\nqa = dspy.Predict(\"question -> answer\")\n\n# Add reasoning if needed\nqa = dspy.ChainOfThought(\"question -> answer\")\n\n# Add optimization when you have data\noptimized_qa = optimizer.compile(qa, trainset=data)\n```\n\n### 2. Use Descriptive Signatures\n\n```python\n# ❌ Bad: Vague\nclass Task(dspy.Signature):\n    input = dspy.InputField()\n    output = dspy.OutputField()\n\n# ✅ Good: Descriptive\nclass SummarizeArticle(dspy.Signature):\n    \"\"\"Summarize news articles into 3-5 key points.\"\"\"\n    article = dspy.InputField(desc=\"full article text\")\n    summary = dspy.OutputField(desc=\"bullet points, 3-5 items\")\n```\n\n### 3. Optimize with Representative Data\n\n```python\n# Create diverse training examples\ntrainset = [\n    dspy.Example(question=\"factual\", answer=\"...).with_inputs(\"question\"),\n    dspy.Example(question=\"reasoning\", answer=\"...\").with_inputs(\"question\"),\n    dspy.Example(question=\"calculation\", answer=\"...\").with_inputs(\"question\"),\n]\n\n# Use validation set for metric\ndef metric(example, pred, trace=None):\n    return example.answer in pred.answer\n```\n\n### 4. Save and Load Optimized Models\n\n```python\n# Save\noptimized_qa.save(\"models\u002Fqa_v1.json\")\n\n# Load\nloaded_qa = dspy.ChainOfThought(\"question -> answer\")\nloaded_qa.load(\"models\u002Fqa_v1.json\")\n```\n\n### 5. Monitor and Debug\n\n```python\n# Enable tracing\ndspy.settings.configure(lm=lm, trace=[])\n\n# Run prediction\nresult = qa(question=\"...\")\n\n# Inspect trace\nfor call in dspy.settings.trace:\n    print(f\"Prompt: {call['prompt']}\")\n    print(f\"Response: {call['response']}\")\n```\n\n## Comparison to Other Approaches\n\n| Feature | Manual Prompting | LangChain | DSPy |\n|---------|-----------------|-----------|------|\n| Prompt Engineering | Manual | Manual | Automatic |\n| Optimization | Trial & error | None | Data-driven |\n| Modularity | Low | Medium | High |\n| Type Safety | No | Limited | Yes (Signatures) |\n| Portability | Low | Medium | High |\n| Learning Curve | Low | Medium | Medium-High |\n\n**When to choose DSPy:**\n- You have training data or can generate it\n- You need systematic prompt improvement\n- You're building complex multi-stage systems\n- You want to optimize across different LMs\n\n**When to choose alternatives:**\n- Quick prototypes (manual prompting)\n- Simple chains with existing tools (LangChain)\n- Custom optimization logic needed\n\n## Resources\n\n- **Documentation**: https:\u002F\u002Fdspy.ai\n- **GitHub**: https:\u002F\u002Fgithub.com\u002Fstanfordnlp\u002Fdspy (22k+ stars)\n- **Discord**: https:\u002F\u002Fdiscord.gg\u002FXCGy2WDCQB\n- **Twitter**: @DSPyOSS\n- **Paper**: \"DSPy: Compiling Declarative Language Model Calls into Self-Improving Pipelines\"\n\n## See Also\n\n- `references\u002Fmodules.md` - Detailed module guide (Predict, ChainOfThought, ReAct, ProgramOfThought)\n- `references\u002Foptimizers.md` - Optimization algorithms (BootstrapFewShot, MIPRO, BootstrapFinetune)\n- `references\u002Fexamples.md` - Real-world examples (RAG, agents, classifiers)\n\n\n","# DSPy: Declarative Language Model Programming\n\n## When to Use This Skill\n\nUse DSPy when you need to:\n- **Build complex AI systems** with multiple components and workflows\n- **Program LMs declaratively** instead of manual prompt engineering\n- **Optimize prompts automatically** using data-driven methods\n- **Create modular AI pipelines** that are maintainable and portable\n- **Improve model outputs systematically** with optimizers\n- **Build RAG systems, agents, or classifiers** with better reliability\n\n**GitHub Stars**: 22,000+ | **Created By**: Stanford NLP\n\n## Installation\n\n```bash\n# Stable release\npip install dspy\n\n# Latest development version\npip install git+https:\u002F\u002Fgithub.com\u002Fstanfordnlp\u002Fdspy.git\n\n# With specific LM providers\npip install dspy[openai]        # OpenAI\npip install dspy[anthropic]     # Anthropic Claude\npip install dspy[all]           # All providers\n```\n\n## Quick Start\n\n### Basic Example: Question Answering\n\n```python\nimport dspy\n\n# Configure your language model\nlm = dspy.Claude(model=\"claude-sonnet-4-5-20250929\")\ndspy.settings.configure(lm=lm)\n\n# Define a signature (input → output)\nclass QA(dspy.Signature):\n    \"\"\"Answer questions with short factual answers.\"\"\"\n    question = dspy.InputField()\n    answer = dspy.OutputField(desc=\"often between 1 and 5 words\")\n\n# Create a module\nqa = dspy.Predict(QA)\n\n# Use it\nresponse = qa(question=\"What is the capital of France?\")\nprint(response.answer)  # \"Paris\"\n```\n\n### Chain of Thought Reasoning\n\n```python\nimport dspy\n\nlm = dspy.Claude(model=\"claude-sonnet-4-5-20250929\")\ndspy.settings.configure(lm=lm)\n\n# Use ChainOfThought for better reasoning\nclass MathProblem(dspy.Signature):\n    \"\"\"Solve math word problems.\"\"\"\n    problem = dspy.InputField()\n    answer = dspy.OutputField(desc=\"numerical answer\")\n\n# ChainOfThought generates reasoning steps automatically\ncot = dspy.ChainOfThought(MathProblem)\n\nresponse = cot(problem=\"If John has 5 apples and gives 2 to Mary, how many does he have?\")\nprint(response.rationale)  # Shows reasoning steps\nprint(response.answer)     # \"3\"\n```\n\n## Core Concepts\n\n### 1. Signatures\n\nSignatures define the structure of your AI task (inputs → outputs):\n\n```python\n# Inline signature (simple)\nqa = dspy.Predict(\"question -> answer\")\n\n# Class signature (detailed)\nclass Summarize(dspy.Signature):\n    \"\"\"Summarize text into key points.\"\"\"\n    text = dspy.InputField()\n    summary = dspy.OutputField(desc=\"bullet points, 3-5 items\")\n\nsummarizer = dspy.ChainOfThought(Summarize)\n```\n\n**When to use each:**\n- **Inline**: Quick prototyping, simple tasks\n- **Class**: Complex tasks, type hints, better documentation\n\n### 2. Modules\n\nModules are reusable components that transform inputs to outputs:\n\n#### dspy.Predict\nBasic prediction module:\n\n```python\npredictor = dspy.Predict(\"context, question -> answer\")\nresult = predictor(context=\"Paris is the capital of France\",\n                   question=\"What is the capital?\")\n```\n\n#### dspy.ChainOfThought\nGenerates reasoning steps before answering:\n\n```python\ncot = dspy.ChainOfThought(\"question -> answer\")\nresult = cot(question=\"Why is the sky blue?\")\nprint(result.rationale)  # Reasoning steps\nprint(result.answer)     # Final answer\n```\n\n#### dspy.ReAct\nAgent-like reasoning with tools:\n\n```python\nfrom dspy.predict import ReAct\n\nclass SearchQA(dspy.Signature):\n    \"\"\"Answer questions using search.\"\"\"\n    question = dspy.InputField()\n    answer = dspy.OutputField()\n\ndef search_tool(query: str) -> str:\n    \"\"\"Search Wikipedia.\"\"\"\n    # Your search implementation\n    return results\n\nreact = ReAct(SearchQA, tools=[search_tool])\nresult = react(question=\"When was Python created?\")\n```\n\n#### dspy.ProgramOfThought\nGenerates and executes code for reasoning:\n\n```python\npot = dspy.ProgramOfThought(\"question -> answer\")\nresult = pot(question=\"What is 15% of 240?\")\n# Generates: answer = 240 * 0.15\n```\n\n### 3. Optimizers\n\nOptimizers improve your modules automatically using training data:\n\n#### BootstrapFewShot\nLearns from examples:\n\n```python\nfrom dspy.teleprompt import BootstrapFewShot\n\n# Training data\ntrainset = [\n    dspy.Example(question=\"What is 2+2?\", answer=\"4\").with_inputs(\"question\"),\n    dspy.Example(question=\"What is 3+5?\", answer=\"8\").with_inputs(\"question\"),\n]\n\n# Define metric\ndef validate_answer(example, pred, trace=None):\n    return example.answer == pred.answer\n\n# Optimize\noptimizer = BootstrapFewShot(metric=validate_answer, max_bootstrapped_demos=3)\noptimized_qa = optimizer.compile(qa, trainset=trainset)\n\n# Now optimized_qa performs better!\n```\n\n#### MIPRO (Most Important Prompt Optimization)\nIteratively improves prompts:\n\n```python\nfrom dspy.teleprompt import MIPRO\n\noptimizer = MIPRO(\n    metric=validate_answer,\n    num_candidates=10,\n    init_temperature=1.0\n)\n\noptimized_cot = optimizer.compile(\n    cot,\n    trainset=trainset,\n    num_trials=100\n)\n```\n\n#### BootstrapFinetune\nCreates datasets for model fine-tuning:\n\n```python\nfrom dspy.teleprompt import BootstrapFinetune\n\noptimizer = BootstrapFinetune(metric=validate_answer)\noptimized_module = optimizer.compile(qa, trainset=trainset)\n\n# Exports training data for fine-tuning\n```\n\n### 4. Building Complex Systems\n\n#### Multi-Stage Pipeline\n\n```python\nimport dspy\n\nclass MultiHopQA(dspy.Module):\n    def __init__(self):\n        super().__init__()\n        self.retrieve = dspy.Retrieve(k=3)\n        self.generate_query = dspy.ChainOfThought(\"question -> search_query\")\n        self.generate_answer = dspy.ChainOfThought(\"context, question -> answer\")\n\n    def forward(self, question):\n        # Stage 1: Generate search query\n        search_query = self.generate_query(question=question).search_query\n\n        # Stage 2: Retrieve context\n        passages = self.retrieve(search_query).passages\n        context = \"\\n\".join(passages)\n\n        # Stage 3: Generate answer\n        answer = self.generate_answer(context=context, question=question).answer\n        return dspy.Prediction(answer=answer, context=context)\n\n# Use the pipeline\nqa_system = MultiHopQA()\nresult = qa_system(question=\"Who wrote the book that inspired the movie Blade Runner?\")\n```\n\n#### RAG System with Optimization\n\n```python\nimport dspy\nfrom dspy.retrieve.chromadb_rm import ChromadbRM\n\n# Configure retriever\nretriever = ChromadbRM(\n    collection_name=\"documents\",\n    persist_directory=\".\u002Fchroma_db\"\n)\n\nclass RAG(dspy.Module):\n    def __init__(self, num_passages=3):\n        super().__init__()\n        self.retrieve = dspy.Retrieve(k=num_passages)\n        self.generate = dspy.ChainOfThought(\"context, question -> answer\")\n\n    def forward(self, question):\n        context = self.retrieve(question).passages\n        return self.generate(context=context, question=question)\n\n# Create and optimize\nrag = RAG()\n\n# Optimize with training data\nfrom dspy.teleprompt import BootstrapFewShot\n\noptimizer = BootstrapFewShot(metric=validate_answer)\noptimized_rag = optimizer.compile(rag, trainset=trainset)\n```\n\n## LM Provider Configuration\n\n### Anthropic Claude\n\n```python\nimport dspy\n\nlm = dspy.Claude(\n    model=\"claude-sonnet-4-5-20250929\",\n    api_key=\"your-api-key\",  # Or set ANTHROPIC_API_KEY env var\n    max_tokens=1000,\n    temperature=0.7\n)\ndspy.settings.configure(lm=lm)\n```\n\n### OpenAI\n\n```python\nlm = dspy.OpenAI(\n    model=\"gpt-4\",\n    api_key=\"your-api-key\",\n    max_tokens=1000\n)\ndspy.settings.configure(lm=lm)\n```\n\n### Local Models (Ollama)\n\n```python\nlm = dspy.OllamaLocal(\n    model=\"llama3.1\",\n    base_url=\"http:\u002F\u002Flocalhost:11434\"\n)\ndspy.settings.configure(lm=lm)\n```\n\n### Multiple Models\n\n```python\n# Different models for different tasks\ncheap_lm = dspy.OpenAI(model=\"gpt-3.5-turbo\")\nstrong_lm = dspy.Claude(model=\"claude-sonnet-4-5-20250929\")\n\n# Use cheap model for retrieval, strong model for reasoning\nwith dspy.settings.context(lm=cheap_lm):\n    context = retriever(question)\n\nwith dspy.settings.context(lm=strong_lm):\n    answer = generator(context=context, question=question)\n```\n\n## Common Patterns\n\n### Pattern 1: Structured Output\n\n```python\nfrom pydantic import BaseModel, Field\n\nclass PersonInfo(BaseModel):\n    name: str = Field(description=\"Full name\")\n    age: int = Field(description=\"Age in years\")\n    occupation: str = Field(description=\"Current job\")\n\nclass ExtractPerson(dspy.Signature):\n    \"\"\"Extract person information from text.\"\"\"\n    text = dspy.InputField()\n    person: PersonInfo = dspy.OutputField()\n\nextractor = dspy.TypedPredictor(ExtractPerson)\nresult = extractor(text=\"John Doe is a 35-year-old software engineer.\")\nprint(result.person.name)  # \"John Doe\"\nprint(result.person.age)   # 35\n```\n\n### Pattern 2: Assertion-Driven Optimization\n\n```python\nimport dspy\nfrom dspy.primitives.assertions import assert_transform_module, backtrack_handler\n\nclass MathQA(dspy.Module):\n    def __init__(self):\n        super().__init__()\n        self.solve = dspy.ChainOfThought(\"problem -> solution: float\")\n\n    def forward(self, problem):\n        solution = self.solve(problem=problem).solution\n\n        # Assert solution is numeric\n        dspy.Assert(\n            isinstance(float(solution), float),\n            \"Solution must be a number\",\n            backtrack=backtrack_handler\n        )\n\n        return dspy.Prediction(solution=solution)\n```\n\n### Pattern 3: Self-Consistency\n\n```python\nimport dspy\nfrom collections import Counter\n\nclass ConsistentQA(dspy.Module):\n    def __init__(self, num_samples=5):\n        super().__init__()\n        self.qa = dspy.ChainOfThought(\"question -> answer\")\n        self.num_samples = num_samples\n\n    def forward(self, question):\n        # Generate multiple answers\n        answers = []\n        for _ in range(self.num_samples):\n            result = self.qa(question=question)\n            answers.append(result.answer)\n\n        # Return most common answer\n        most_common = Counter(answers).most_common(1)[0][0]\n        return dspy.Prediction(answer=most_common)\n```\n\n### Pattern 4: Retrieval with Reranking\n\n```python\nclass RerankedRAG(dspy.Module):\n    def __init__(self):\n        super().__init__()\n        self.retrieve = dspy.Retrieve(k=10)\n        self.rerank = dspy.Predict(\"question, passage -> relevance_score: float\")\n        self.answer = dspy.ChainOfThought(\"context, question -> answer\")\n\n    def forward(self, question):\n        # Retrieve candidates\n        passages = self.retrieve(question).passages\n\n        # Rerank passages\n        scored = []\n        for passage in passages:\n            score = float(self.rerank(question=question, passage=passage).relevance_score)\n            scored.append((score, passage))\n\n        # Take top 3\n        top_passages = [p for _, p in sorted(scored, reverse=True)[:3]]\n        context = \"\\n\\n\".join(top_passages)\n\n        # Generate answer\n        return self.answer(context=context, question=question)\n```\n\n## Evaluation and Metrics\n\n### Custom Metrics\n\n```python\ndef exact_match(example, pred, trace=None):\n    \"\"\"Exact match metric.\"\"\"\n    return example.answer.lower() == pred.answer.lower()\n\ndef f1_score(example, pred, trace=None):\n    \"\"\"F1 score for text overlap.\"\"\"\n    pred_tokens = set(pred.answer.lower().split())\n    gold_tokens = set(example.answer.lower().split())\n\n    if not pred_tokens:\n        return 0.0\n\n    precision = len(pred_tokens & gold_tokens) \u002F len(pred_tokens)\n    recall = len(pred_tokens & gold_tokens) \u002F len(gold_tokens)\n\n    if precision + recall == 0:\n        return 0.0\n\n    return 2 * (precision * recall) \u002F (precision + recall)\n```\n\n### Evaluation\n\n```python\nfrom dspy.evaluate import Evaluate\n\n# Create evaluator\nevaluator = Evaluate(\n    devset=testset,\n    metric=exact_match,\n    num_threads=4,\n    display_progress=True\n)\n\n# Evaluate model\nscore = evaluator(qa_system)\nprint(f\"Accuracy: {score}\")\n\n# Compare optimized vs unoptimized\nscore_before = evaluator(qa)\nscore_after = evaluator(optimized_qa)\nprint(f\"Improvement: {score_after - score_before:.2%}\")\n```\n\n## Best Practices\n\n### 1. Start Simple, Iterate\n\n```python\n# Start with Predict\nqa = dspy.Predict(\"question -> answer\")\n\n# Add reasoning if needed\nqa = dspy.ChainOfThought(\"question -> answer\")\n\n# Add optimization when you have data\noptimized_qa = optimizer.compile(qa, trainset=data)\n```\n\n### 2. Use Descriptive Signatures\n\n```python\n# ❌ Bad: Vague\nclass Task(dspy.Signature):\n    input = dspy.InputField()\n    output = dspy.OutputField()\n\n# ✅ Good: Descriptive\nclass SummarizeArticle(dspy.Signature):\n    \"\"\"Summarize news articles into 3-5 key points.\"\"\"\n    article = dspy.InputField(desc=\"full article text\")\n    summary = dspy.OutputField(desc=\"bullet points, 3-5 items\")\n```\n\n### 3. Optimize with Representative Data\n\n```python\n# Create diverse training examples\ntrainset = [\n    dspy.Example(question=\"factual\", answer=\"...).with_inputs(\"question\"),\n    dspy.Example(question=\"reasoning\", answer=\"...\").with_inputs(\"question\"),\n    dspy.Example(question=\"calculation\", answer=\"...\").with_inputs(\"question\"),\n]\n\n# Use validation set for metric\ndef metric(example, pred, trace=None):\n    return example.answer in pred.answer\n```\n\n### 4. Save and Load Optimized Models\n\n```python\n# Save\noptimized_qa.save(\"models\u002Fqa_v1.json\")\n\n# Load\nloaded_qa = dspy.ChainOfThought(\"question -> answer\")\nloaded_qa.load(\"models\u002Fqa_v1.json\")\n```\n\n### 5. Monitor and Debug\n\n```python\n# Enable tracing\ndspy.settings.configure(lm=lm, trace=[])\n\n# Run prediction\nresult = qa(question=\"...\")\n\n# Inspect trace\nfor call in dspy.settings.trace:\n    print(f\"Prompt: {call['prompt']}\")\n    print(f\"Response: {call['response']}\")\n```\n\n## Comparison to Other Approaches\n\n| Feature | Manual Prompting | LangChain | DSPy |\n|---------|-----------------|-----------|------|\n| Prompt Engineering | Manual | Manual | Automatic |\n| Optimization | Trial & error | None | Data-driven |\n| Modularity | Low | Medium | High |\n| Type Safety | No | Limited | Yes (Signatures) |\n| Portability | Low | Medium | High |\n| Learning Curve | Low | Medium | Medium-High |\n\n**When to choose DSPy:**\n- You have training data or can generate it\n- You need systematic prompt improvement\n- You're building complex multi-stage systems\n- You want to optimize across different LMs\n\n**When to choose alternatives:**\n- Quick prototypes (manual prompting)\n- Simple chains with existing tools (LangChain)\n- Custom optimization logic needed\n\n## Resources\n\n- **Documentation**: https:\u002F\u002Fdspy.ai\n- **GitHub**: https:\u002F\u002Fgithub.com\u002Fstanfordnlp\u002Fdspy (22k+ stars)\n- **Discord**: https:\u002F\u002Fdiscord.gg\u002FXCGy2WDCQB\n- **Twitter**: @DSPyOSS\n- **Paper**: \"DSPy: Compiling Declarative Language Model Calls into Self-Improving Pipelines\"\n\n## See Also\n\n- `references\u002Fmodules.md` - Detailed module guide (Predict, ChainOfThought, ReAct, ProgramOfThought)\n- `references\u002Foptimizers.md` - Optimization algorithms (BootstrapFewShot, MIPRO, BootstrapFinetune)\n- `references\u002Fexamples.md` - Real-world examples (RAG, agents, classifiers)\n\n\n",{"name":5,"tags":23,"author":34,"license":14,"version":35,"description":7,"dependencies":36},[24,25,26,27,28,29,30,31,32,33],"Prompt Engineering","DSPy","Declarative Programming","RAG","Agents","Prompt Optimization","LM Programming","Stanford NLP","Automatic Optimization","Modular AI","Orchestra Research","1.0.0",[5,37,38],"openai","anthropic","main","46e03791269608c5ac886a64c08f5d94147e8786","labs\u002F.codex\u002Fskills\u002Fdspy","https:\u002F\u002Fgithub.com\u002Fbeyondai\u002Fsandbox","https:\u002F\u002Fgithub.com\u002Fbeyondai","2026-11-08 04:18:42",{"source":8,"skillName":5,"commands":46,"prompt":56,"zipAvailable":57},[47,50,53],{"tool":48,"command":49},"npx","npx skills add beyondai\u002Fsandbox --skill dspy",{"tool":51,"command":52},"bunx","bunx skills add beyondai\u002Fsandbox --skill dspy",{"tool":54,"command":55},"pnpm","pnpm dlx skills add beyondai\u002Fsandbox --skill dspy","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fbeyondai\u002Fsandbox\u002Fblob\u002Fmain\u002Flabs\u002F.codex\u002Fskills\u002Fdspy\u002FSKILL.md",true,[59,65,69],{"path":60,"resourceType":61,"resourceTypeDesc":62,"sizeBytes":63,"sourceHtmlUrl":64},"references\u002Fexamples.md","REFERENCE","参考文档",18983,"https:\u002F\u002Fgithub.com\u002Fbeyondai\u002Fsandbox\u002Fblob\u002Fmain\u002Flabs\u002F.codex\u002Fskills\u002Fdspy\u002Freferences\u002Fexamples.md",{"path":66,"resourceType":61,"resourceTypeDesc":62,"sizeBytes":67,"sourceHtmlUrl":68},"references\u002Fmodules.md",12363,"https:\u002F\u002Fgithub.com\u002Fbeyondai\u002Fsandbox\u002Fblob\u002Fmain\u002Flabs\u002F.codex\u002Fskills\u002Fdspy\u002Freferences\u002Fmodules.md",{"path":70,"resourceType":61,"resourceTypeDesc":62,"sizeBytes":71,"sourceHtmlUrl":72},"references\u002Foptimizers.md",14933,"https:\u002F\u002Fgithub.com\u002Fbeyondai\u002Fsandbox\u002Fblob\u002Fmain\u002Flabs\u002F.codex\u002Fskills\u002Fdspy\u002Freferences\u002Foptimizers.md",[74,81,88,95,102,109],{"skillNo":75,"name":76,"nameZh":6,"description":77,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":78,"categories":79,"keywords":80,"publishedAt":18},"01M7D3GMPGJZRG8EPY404YF8TR","weights-and-biases","Track ML experiments with automatic logging, visualize training in real-time, optimize hyperparameters with sweeps, and manage model registry with W&B - collaborative MLOps platform","https:\u002F\u002Fgithub.com\u002Fbeyondai\u002Fsandbox\u002Fblob\u002Fmain\u002Flabs\u002F.opencode\u002Fskills\u002Fweights-and-biases\u002FSKILL.md",[],[],{"skillNo":82,"name":83,"nameZh":6,"description":84,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":85,"categories":86,"keywords":87,"publishedAt":18},"01M7D3GFZH440V2J532BSZMPVP","serving-llms-vllm","Serves LLMs with high throughput using vLLM's PagedAttention and continuous batching. Use when deploying production LLM APIs, optimizing inference latency\u002Fthroughput, or serving models with limited GPU memory. Supports OpenAI-compatible endpoints, quantization (GPTQ\u002FAWQ\u002FFP8), and tensor parallelism.","https:\u002F\u002Fgithub.com\u002Fbeyondai\u002Fsandbox\u002Fblob\u002Fmain\u002Flabs\u002F.opencode\u002Fskills\u002Fvllm\u002FSKILL.md",[],[],{"skillNo":89,"name":90,"nameZh":6,"description":91,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":92,"categories":93,"keywords":94,"publishedAt":18},"01M7D3GAE8MQCPGF72EP9G9GKY","verl-rl-training","Provides guidance for training LLMs with reinforcement learning using verl (Volcano Engine RL). Use when implementing RLHF, GRPO, PPO, or other RL algorithms for LLM post-training at scale with flexible infrastructure backends.","https:\u002F\u002Fgithub.com\u002Fbeyondai\u002Fsandbox\u002Fblob\u002Fmain\u002Flabs\u002F.opencode\u002Fskills\u002Fverl\u002FSKILL.md",[],[],{"skillNo":96,"name":97,"nameZh":6,"description":98,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":99,"categories":100,"keywords":101,"publishedAt":18},"01M7D3G7KKNE5RGNYJNXV4F0MM","unsloth","Expert guidance for fast fine-tuning with Unsloth - 2-5x faster training, 50-80% less memory, LoRA\u002FQLoRA optimization","https:\u002F\u002Fgithub.com\u002Fbeyondai\u002Fsandbox\u002Fblob\u002Fmain\u002Flabs\u002F.opencode\u002Fskills\u002Funsloth\u002FSKILL.md",[],[],{"skillNo":103,"name":104,"nameZh":6,"description":105,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":106,"categories":107,"keywords":108,"publishedAt":18},"01M7D3G2RCZQ08GS0KAW5CBWSC","fine-tuning-with-trl","Fine-tune LLMs using reinforcement learning with TRL - SFT for instruction tuning, DPO for preference alignment, PPO\u002FGRPO for reward optimization, and reward model training. Use when need RLHF, align model with preferences, or train from human feedback. Works with HuggingFace Transformers.","https:\u002F\u002Fgithub.com\u002Fbeyondai\u002Fsandbox\u002Fblob\u002Fmain\u002Flabs\u002F.opencode\u002Fskills\u002Ftrl-fine-tuning\u002FSKILL.md",[],[],{"skillNo":110,"name":111,"nameZh":6,"description":112,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":113,"categories":114,"keywords":115,"publishedAt":18},"01M7D3FX08BPB172CYGM597NZF","torchforge-rl-training","Provides guidance for PyTorch-native agentic RL using torchforge, Meta's library separating infra from algorithms. Use when you want clean RL abstractions, easy algorithm experimentation, or scalable training with Monarch and TorchTitan.","https:\u002F\u002Fgithub.com\u002Fbeyondai\u002Fsandbox\u002Fblob\u002Fmain\u002Flabs\u002F.opencode\u002Fskills\u002Ftorchforge\u002FSKILL.md",[],[]]