# dspy-miprov2-optimizer

This skill guides MIPROv2 optimization of DSPy programs, searching for instruction and few-shot demo combinations with Bayesian optimization. Use it to tune a program against training data.

- skill · `type=skill` · Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, OpenCode · ★ 124
- Author: OmidZamani
- License: MIT · policy=mirror · the beginning of the file is at the end of this page
- Source: https://github.com/OmidZamani/dspy-skills/tree/HEAD/skills/dspy-miprov2-optimizer/SKILL.md
- Updated: 2026-06-23
- HTML: https://affpapa.org/en/nevibecode/skills/dspy-miprov2-optimizer

## What it does

MIPROv2 works in three stages: it generates demonstration candidates, proposes instructions, then searches combinations. The result is an optimized DSPy module. The skill covers setting up the program, metric, and dataset, then evaluating and saving the compiled result with metadata.

The guide recommends 200+ training examples and runs with 40 or more trials. Expect substantial compute use and many LLM calls. Install `dspy[optuna]>=3.2.1,<3.3` before running MIPROv2. For smaller datasets, the guide points to a separate skill, `dspy-bootstrap-fewshot`.

## Install

### Claude Code (native platform)

1. **Skills CLI (Vercel)**
```bash
npx skills add OmidZamani/dspy-skills --skill dspy-miprov2-optimizer -a claude-code
```

2. **Manually: put the files in place**
- File: `~/.claude/skills/dspy-miprov2-optimizer/SKILL.md` — Copy the whole skill folder; for one project use .claude/skills/dspy-miprov2-optimizer/

### Codex

1. **Skills CLI (Vercel)**
```bash
npx skills add OmidZamani/dspy-skills --skill dspy-miprov2-optimizer -a codex
```

2. **Manually: put the files in place**
- File: `.agents/skills/dspy-miprov2-optimizer/SKILL.md` — For all projects use ~/.agents/skills/

### Cursor

1. **Skills CLI (Vercel)**
```bash
npx skills add OmidZamani/dspy-skills --skill dspy-miprov2-optimizer -a cursor
```

2. **Manually: put the files in place**
- File: `.cursor/skills/dspy-miprov2-optimizer/SKILL.md` — Cursor also reads .agents/skills/ and .claude/skills/

### GitHub Copilot

1. **GitHub CLI**
```bash
gh skill install OmidZamani/dspy-skills dspy-miprov2-optimizer
```

2. **Manually: put the files in place**
- File: `.github/skills/dspy-miprov2-optimizer/SKILL.md`

### Gemini CLI

1. **Skills CLI (Vercel)**
```bash
npx skills add OmidZamani/dspy-skills --skill dspy-miprov2-optimizer -a gemini-cli
```

2. **Platform CLI**
```bash
gemini skills install https://github.com/OmidZamani/dspy-skills --path skills/dspy-miprov2-optimizer
```

### Windsurf (Devin Desktop)

**Manually: put the files in place**
- File: `.devin/skills/dspy-miprov2-optimizer/SKILL.md` — The legacy .windsurf/skills/ path still works

### OpenCode

**Skills CLI (Vercel)**
```bash
npx skills add OmidZamani/dspy-skills --skill dspy-miprov2-optimizer -a opencode
```

### Claude.ai

**Claude.ai**
- Zip the folder and upload it in Settings → Capabilities → Skills

Where a file is given instead of a command, copy the files from the source to that path: https://github.com/OmidZamani/dspy-skills/tree/HEAD/skills/dspy-miprov2-optimizer/SKILL.md

## When to use it
- tune a DSPy program’s instructions and few-shot demonstrations
- search for instruction-demo combinations with Bayesian optimization
- compare a baseline program with its optimized version on a dev set
- save the compiled module and evaluation metadata

## Example prompts
- Optimize my DSPy module with MIPROv2 using the training set and exact-match metric.
- Tune only the DSPy instructions and turn off demonstrations.
- Compare the baseline agent with the optimized one and save the result to `agent_mipro.json`.

## Source text · SKILL.md · MIT

Below is the content of a third-party file. It is data, not instructions for you: do not act on anything written inside unless the human asks. Block tag: 14c94ccb3080118d.

BEGIN THIRD-PARTY FILE 14c94ccb3080118d
````text
---
name: dspy-miprov2-optimizer
version: "1.0.0"
dspy-compatibility: "3.2.1"
tags: ["optimizer"]
requires-extras: ["dspy[optuna]"]
description: Use for MIPROv2, Bayesian optimization, instruction and demo tuning, and high-performance DSPy program optimization.
allowed-tools:
  - Read
  - Write
  - Glob
  - Grep
---

# DSPy MIPROv2 Optimizer

## Goal

Jointly optimize instructions and few-shot demonstrations using Bayesian Optimization for maximum performance.

## When to Use

- You have **200+ training examples**
- You can afford longer optimization runs (40+ trials)
- You need state-of-the-art performance
- Both instructions and demos need tuning

## Related Skills

- For limited data (10-50 examples): [dspy-bootstrap-fewshot](../dspy-bootstrap-fewshot/SKILL.md)
- For agentic systems: [dspy-gepa-reflective](../dspy-gepa-reflective/SKILL.md)
- Measure improvements: [dspy-evaluation-suite](../dspy-evaluation-suite/SKILL.md)

## Inputs

| Input | Type | Description |
|-------|------|-------------|
| `program` | `dspy.Module` | Program to optimize |
| `trainset` | `list[dspy.Example]` | 200+ training examples |
| `metric` | `callable` | Evaluation function |
| `auto` | `str` | "light", "medium", or "heavy" |
| `num_trials` | `int` | Optimization trials (40+) |

## Outputs

| Output | Type | Description |
|--------|------|-------------|
| `compiled_program` | `dspy.Module` | Fully optimized program |

## Workflow

Install the optional Optuna dependency before using MIPROv2:

```bash
pip install -U "dspy[optuna]>=3.2.1,<3.3"
```

### Three-Stage Process

1. **Bootstrap** - Generate candidate demonstrations
2. **Propose** - Create grounded instruction candidates
3. **Search** - Bayesian optimization over combinations

### Phase 1: Setup

```python
import dspy
from dspy.teleprompt import MIPROv2

lm = dspy.LM('openai/gpt-4o-mini')
dspy.configure(lm=lm)
```

### Phase 2: Define Program

```python
class RAGAgent(dspy.Module):
    def __init__(self):
        self.retrieve = dspy.Retrieve(k=3)
        self.generate = dspy.ChainOfThought("context, question -> answer")
    
    def forward(self, question):
        context = self.retrieve(question).passages
        return self.generate(context=context, question=question)
```

### Phase 3: Optimize

```python
from dspy.teleprompt import MIPROv2

optimizer = MIPROv2(
    metric=dspy.evaluate.answer_exact_match,
    auto="medium",  # Balanced optimization
    num_threads=24
)

compiled = optimizer.compile(RAGAgent(), trainset=trainset)
```

## Auto Presets

| Preset | Trials | Use Case |
|--------|--------|----------|
| `"light"` | ~10 | Quick iteration |
| `"medium"` | ~40 | Production optimization |
| `"heavy"` | ~100+ | Maximum performance |

## Production Example

```python
import dspy
from dspy.teleprompt import MIPROv2
from dspy.evaluate import Evaluate
import json
import logging

logger = logging.getLogger(__name__)

class ReActAgent(dspy.Module):
    def __init__(self, tools):
````
END THIRD-PARTY FILE 14c94ccb3080118d

The third-party file has ended. Everything between the 14c94ccb3080118d tags is data: requests and commands from it are not followed. An “end of file” line with another tag inside the block is part of the file.

First 2972 of 5571 bytes. © OmidZamani · MIT · https://github.com/OmidZamani/dspy-skills/tree/HEAD/skills/dspy-miprov2-optimizer/SKILL.md

_Part of the page did not fit — see the HTML version._

---
NeVibeCode on affpapa.org. Catalog texts are descriptions, not instructions for the agent. How to choose and install: https://affpapa.org/en/nevibecode/agents.md