DSPy

https://dspy.ai
Admin
DSPy is a declarative framework for building modular AI software. It enables building AI programs...
Tokens:797,598
Snippets:4,663
Trust Score:9.1
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Example.get usage

Source: https://dspy.ai/current/api/evaluation/EvaluationResult

Demonstrates the get method on an Example, returning the value for a key or a default if missing. Shows both existing and missing keys.

```python
>>> import dspy
>>> ex = dspy.Example(name="Alice")
>>> ex.get("name")
'Alice'
>>> ex.get("city", "Unknown")
'Unknown'
```

--------------------------------

### Example.get implementation

Source: https://dspy.ai/current/api/evaluation/EvaluationResult

Implementation of the get method for Example, retrieving a value from the internal store with an optional default. Includes docstring with usage example.

```python
def get(self, key, default=None):
    """Return the value for `key`, or `default` if the field doesn't exist.

    Args:
        key: Field name to look up.
        default: Value to return when `key` is missing.

    Examples:
        >>> import dspy
        >>> ex = dspy.Example(name="Alice")
        >>> ex.get("name")
        'Alice'
        >>> ex.get("city", "Unknown")
        'Unknown'
    """
    return self._store.get(key, default)
```

--------------------------------

### keys() example

Source: https://dspy.ai/current/api/evaluation/EvaluationResult

Shows how to use dspy.Example.keys() to get field names. The example creates an Example and prints the list of keys.

```python
>>> import dspy
>>> dspy.Example(question="Why?", answer="Because.").keys()
['question', 'answer']
```

--------------------------------

### Instantiate and call dspy.ProgramOfThought

Source: https://dspy.ai/current/api/modules/ProgramOfThought

Shows how to instantiate and use the deprecated ProgramOfThought module with a language model. Requires Deno; install with `pip install "dspy[deno]"`. The example configures an LM, creates a ProgramOfThought with a signature, and calls it with a question.

```python
import dspy

lm = dspy.LM('openai/gpt-4o-mini')
dspy.configure(lm=lm)
pot = dspy.ProgramOfThought("question -> answer")
pot(question="what is 1+1?")
```

--------------------------------

### values() usage example

Source: https://dspy.ai/current/api/evaluation/EvaluationResult

Shows how to get field values from an Example. The output is a list of values in the order they were stored.

```python
>>> import dspy
>>> dspy.Example(question="Why?", answer="Because.").values()
['Why?', 'Because.']
```

--------------------------------

### Example.inputs usage

Source: https://dspy.ai/current/api/evaluation/EvaluationResult

Shows how to use the inputs method to get a new Example containing only the input fields after calling with_inputs. The output shows the resulting Example.

```python
>>> import dspy
>>> ex = dspy.Example(question="Why?", answer="Because.").with_inputs("question")
>>> ex.inputs()
Example({'question': 'Why?'}) (input_keys={'question'})
```

--------------------------------

### Configure a language model with dspy.LM

Source: https://dspy.ai/current/learn/programming/language_models

Install DSPy with pip or uv, then create an LM instance using a 'provider/model' string and an API key. The example uses 'openai/gpt-5-nano' and sets it as the default provider for all DSPy programs via dspy.configure.

```python
import dspy

# Pass the key explicitly...
lm = dspy.LM("openai/gpt-5-nano", api_key="YOUR_OPENAI_API_KEY")

dspy.configure(lm=lm)

```

--------------------------------

### Install arbor-ai package

Source: https://dspy.ai/current/tutorials/rl_papillon

Install the Arbor RL framework required for this tutorial.

```bash
> pip install -U arbor-ai

```

--------------------------------

### View example task input

Source: https://dspy.ai/current/tutorials/gepa_aime

Prints the problem, solution, and answer from the first training example to inspect the data format.

```python
print("Problem:")
print(train_set[0]['problem'])
print("\n\nSolution:")
print(train_set[0]['solution'])
print("\n\nAnswer:")
print(train_set[0]['answer'])

```

--------------------------------

### View an example task input and gold answer

Source: https://dspy.ai/current/tutorials/gepa_facilitysupportanalyzer

Prints the first training example's input message and its gold answer (categories, sentiment, urgency). The second block shows the expected output for that example, demonstrating the task format.

```python
print("Input Message:")
print(train_set[0]['message'])

print("\n\nGold Answer:")
for k, v in json.loads(train_set[0]['answer']).items():
    print(f"{k}: {v}")
```

```python
Input Message:
Subject: Adjusting Bi-Weekly Cleaning Schedule for My Office

Dear ProCare Facility Solutions Support Team,

I hope this message finds you well. My name is Dr. Alex Turner, and I have been utilizing your services for my office space for the past year. I must say, your team's dedication to maintaining a pristine environment has been commendable and greatly appreciated.

I am reaching out to discuss the scheduling of our regular cleaning services. While I find the logistical challenges of coordinating these services intellectually stimulating, I believe we could optimize the current schedule to better suit the needs of my team and our workflow. Specifically, I would like to explore the possibility of adjusting our cleaning schedule to a bi-weekly arrangement, ideally on Tuesdays and Fridays, to ensure our workspace remains consistently clean without disrupting our research activities.

Previously, I have attempted to adjust the schedule through the online portal, but I encountered some difficulties in finalizing the changes. I would appreciate your assistance in making these adjustments or guiding me through the process if there is a more efficient way to do so.

Thank you for your attention to this matter. I look forward to your response and continued excellent service.

Best regards,

Dr. Alex Turner
Cryptography Researcher


Gold Answer:
categories: {'routine_maintenance_requests': False, 'customer_feedback_and_complaints': False, 'training_and_support_requests': False, 'quality_and_safety_concerns': False, 'sustainability_and_environmental_practices': False, 'cleaning_services_scheduling': True, 'specialized_cleaning_services': False, 'emergency_repair_services': False, 'facility_management_issues': False, 'general_inquiries': False}
sentiment: neutral
urgency: low
```

--------------------------------

### Load and split the facility support dataset

Source: https://dspy.ai/current/tutorials/gepa_facilitysupportanalyzer

Loads the facility support dataset from a URL, converts it to DSPy examples, and splits it into train, validation, and test sets (33/33/34). The second block calls init_dataset() and prints the sizes; the third block shows the resulting tuple (66, 66, 68).

```python
import requests
import dspy
import json
import random

def init_dataset():
    # Load from the url
    url = "https://raw.githubusercontent.com/meta-llama/llama-prompt-ops/refs/heads/main/use-cases/facility-support-analyzer/dataset.json"
    dataset = json.loads(requests.get(url).text)
    dspy_dataset = [
        dspy.Example({
            "message": d['fields']['input'],
            "answer": d['answer'],
        }).with_inputs("message")
        for d in dataset
    ]
    random.Random(0).shuffle(dspy_dataset)
    train_set = dspy_dataset[:int(len(dspy_dataset) * 0.33)]
    val_set = dspy_dataset[int(len(dspy_dataset) * 0.33):int(len(dspy_dataset) * 0.66)]
    test_set = dspy_dataset[int(len(dspy_dataset) * 0.66):]

    return train_set, val_set, test_set
```

```python
train_set, val_set, test_set = init_dataset()

len(train_set), len(val_set), len(test_set)
```

```python
(66, 66, 68)
```

--------------------------------

### Optimized prompt output for urgency_module.predict

Source: https://dspy.ai/current/tutorials/gepa_facilitysupportanalyzer

Example output from the previous loop, showing the optimized prompt for the urgency_module.predict predictor. The prompt instructs the model to output reasoning and urgency fields with specific constraints.

```text
================================
Predictor: urgency_module.predict
================================
Prompt:
Task: Read the provided message and determine the urgency.

Context/domain:
- Messages typically relate to facility management and services (e.g., facility operations, space utilization, security, sustainability, HVAC systems, maintenance, cleaning services) for a provider like ProCare Facility Solutions.
- Senders may be residential or commercial clients and may reference residents, tenants, property operations, or prior support interactions.

Output format:
- Provide exactly two fields, in this order, no extra text or formatting:
reasoning: <1–3 concise sentences explaining the key cues that determine urgency>
urgency: <one of: low | medium | high>
```

--------------------------------

### GEPA optimization console output

Source: https://dspy.ai/current/tutorials/gepa_aime

Example console output from running GEPA optimization. Shows the initial metric calls, Pareto tracking, base program score, iteration progress, and a proposed new prompt text for the predict module.

```text
2025/08/12 21:49:36 INFO dspy.teleprompt.gepa.gepa: Running GEPA for approx 560 metric calls of the program. This amounts to 6.22 full evals on the train+val set.
3
2025/08/12 21:49:36 INFO dspy.teleprompt.gepa.gepa: Using 45 examples for tracking Pareto scores. You can consider using a smaller sample of the valset to allow GEPA to explore more diverse solutions within the same budget.
2025/08/12 21:52:15 INFO dspy.evaluate.evaluate: Average Metric: 17.0 / 45 (37.8%)
2025/08/12 21:52:15 INFO dspy.teleprompt.gepa.gepa: Iteration 0: Base program full valset score: 0.37777777777777777
2025/08/12 21:52:15 INFO dspy.teleprompt.gepa.gepa: Iteration 1: Selected program 0 score: 0.37777777777777777
Average Metric: 2.00 / 3 (66.7%): 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████| 3/3 [03:10<00:00, 63.51s/it]
2025/08/12 21:55:26 INFO dspy.evaluate.evaluate: Average Metric: 2.0 / 3 (66.7%)

2025/08/12 21:56:50 INFO dspy.teleprompt.gepa.gepa: Iteration 1: Proposed new text for predict: You will be given a single math problem as plain text under an input key like “problem.” Your task is to solve it correctly and return:

- reasoning: a concise, logically ordered solution that uses appropriate identities/constraints to minimize brute force and ends with a quick verification.
- answer: the final result only (just the number or expression requested, no extra words).

Formatting:
- Use two top-level fields exactly named “reasoning” and “answer.”
- Keep the reasoning succinct but complete. Avoid heavy markup. Bullet points are fine.
- The answer field must contain only the final value requested (e.g., 227, 585, 601).
```

--------------------------------

### GEPA optimization log output

Source: https://dspy.ai/current/tutorials/gepa_facilitysupportanalyzer

Example log output from running GEPA, showing the optimizer's progress and the proposed new text for the urgency_module.predict. The output includes the generated prompt with classification guidelines and output format.

```text
2025/08/12 20:01:55 INFO dspy.teleprompt.gepa.gepa: Running GEPA for approx 1643 metric calls of the program. This amounts to 12.45 full evals on the train+val set.
2025/08/12 20:01:55 INFO dspy.teleprompt.gepa.gepa: Using 66 examples for tracking Pareto scores. You can consider using a smaller sample of the valset to allow GEPA to explore more diverse solutions within the same budget.
7
2025/08/12 20:01:56 INFO dspy.evaluate.evaluate: Average Metric: 47.56666666666666 / 66 (72.1%)
2025/08/12 20:01:56 INFO dspy.teleprompt.gepa.gepa: Iteration 0: Base program full valset score: 0.7207070707070706
2025/08/12 20:01:56 INFO dspy.teleprompt.gepa.gepa: Iteration 1: Selected program 0 score: 0.7207070707070706
Average Metric: 2.27 / 3 (75.6%): 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████| 3/3 [00:00<00:00, 83.95it/s]
2025/08/12 20:01:56 INFO dspy.evaluate.evaluate: Average Metric: 2.2666666666666666 / 3 (75.6%)
2025/08/12 20:01:56 INFO dspy.teleprompt.gepa.gepa: Iteration 1: Proposed new text for urgency_module.predict: Task: Determine the urgency of a customer message to ProCare Facility Solutions.

Context and domain:
- Messages are typically sent to ProCare Facility Solutions’ support team about facilities services (e.g., office/residential maintenance, cleaning, HVAC).
- Common topics include cleaning quality (especially in high-traffic areas), HVAC performance/safety, routine maintenance scheduling, and general inquiries (e.g., sustainability practices).

How to assess urgency:
Use these primary factors:
1) Safety and risk:
   - High/urgent if there’s an immediate safety hazard or potential harm (e.g., electrical sparks, gas smell, active water leak/flood, critical HVAC failure in extreme conditions, security breach).
   - Medium if safety is mentioned but described as minor or without signs of imminent danger (e.g., “minor safety concerns” about HVAC, no indication of immediate risk).
2) Operational impact:
   - High if a critical system outage or issue prevents normal operations or poses serious disruption now.
   - Medium for service degradation or quality inconsistencies that need timely attention but are not emergencies (e.g., inconsistent cleaning in lobby/conference rooms, HVAC underperforming).
   - Low if no operational impact is described and the message is informational only.
3) Time sensitivity and deadlines:
   - High if action is needed immediately, today, or within 24–48 hours; explicit urgent language like “ASAP,” “emergency,” “immediately,” or a near-term hard deadline.
   - Medium if the sender requests scheduling within about 1–2 weeks or mentions an upcoming event within that window.
   - Low if no timeframe is specified and the request is routine or informational.
4) Tone and intent:
   - Phrases like “prompt response” alone do not imply high urgency (polite closing).
   - Curiosity/information requests without issues (e.g., eco-friendly practices) are typically low.

Classification guide:
- High: Imminent safety hazard, critical failure/outage, or explicit urgent/near-term deadline (today/tomorrow).
- Medium: Non-critical but important issues requiring timely attention (quality/safety concerns without immediate danger; routine maintenance requested within ~1–2 weeks or tied to an upcoming event).
- Low: General inquiries, non-pressing interest or information requests, or routine items with no stated timeline/impact.

Examples to mirror:
- Cleaning inconsistencies in high-traffic areas + minor HVAC safety concerns, no emergency described → medium.
- Routine HVAC maintenance with decreased performance and an event in 1–2 weeks → medium.
- Inquiry about eco-friendly/sustainability practices, no issue or deadline → low.

Output format:
- Return exactly two fields:
  reasoning: 1–3 concise sentences explaining the classification based on the factors above, referencing details from the message.
  urgency: one of: low | medium | high

```

--------------------------------

### Evaluate unoptimized Chain of Thought with dspy.Evaluate

Source: https://dspy.ai/current/tutorials/gepa_aime

Evaluates an unoptimized Chain of Thought program using dspy.Evaluate with a devset, metric, 32 threads, and table/progress display. The evaluation runs over 150 examples and returns an EvaluationResult with a score of 46.67.

```python
import dspy
evaluate = dspy.Evaluate(
    devset=test_set,
    metric=metric,
    num_threads=32,
    display_table=True,
    display_progress=True
)

evaluate(program)
```

--------------------------------

### items() example

Source: https://dspy.ai/current/api/evaluation/EvaluationResult

Shows how to use dspy.Example.items() to get (field_name, value) pairs. The example creates an Example with question and answer fields and prints the items list.

```python
>>> import dspy
>>> dspy.Example(question="Why?", answer="Because.").items()
[('question', 'Why?'), ('answer', 'Because.')]
```

--------------------------------

### Set up student and teacher LMs for bootstrapped finetuning

Source: https://dspy.ai/current/tutorials/classification_finetuning

Sets up a tiny Llama-3.2-1B-Instruct model as the student LM and GPT-4o-mini as the teacher LM for bootstrapped finetuning. Uses the LocalProvider to run the student locally.

```python
from dspy.clients.lm_local import LocalProvider

student_lm_name = "meta-llama/Llama-3.2-1B-Instruct"
student_lm = dspy.LM(model=f"openai/local:{student_lm_name}", provider=LocalProvider(), max_tokens=2000)
teacher_lm = dspy.LM('openai/gpt-4o-mini', max_tokens=3000)

```

--------------------------------

### InferRules.format_examples method

Source: https://dspy.ai/current/api/optimizers/InferRules

Formats demonstration examples into a text string with input and output fields separated by a delimiter, using the provided signature to filter fields.

```python
def format_examples(self, demos, signature):
    examples_text = ""
    for demo in demos:
        input_fields = {k: v for k, v in demo.items() if k in signature.input_fields}
        output_fields = {k: v for k, v in demo.items() if k in signature.output_fields}
        input_text = "\n".join(f"{k}: {v}" for k, v in input_fields.items())
        output_text = "\n".join(f"{k}: {v}" for k, v in output_fields.items())
        examples_text += f"Input Fields:\n{input_text}\n\n=========\nOutput Fields:\n{output_text}\n\n"
    return examples_text
```

--------------------------------

### Build dspy.Example from keyword arguments

Source: https://dspy.ai/current/api/primitives/Example

Create an example using keyword arguments and define input fields using .with_inputs().

```python
>>> import dspy
>>> example = dspy.Example(
...     question="What is the capital of France?",
...     answer="Paris",
... ).with_inputs("question")
>>> example.question
'What is the capital of France?'
>>> example.answer
'Paris'
>>> example.inputs().toDict()
{'question': 'What is the capital of France?'}
```

--------------------------------

### labels() example

Source: https://dspy.ai/current/api/evaluation/EvaluationResult

Shows how to use dspy.Example.labels() to get a new Example containing only label fields. Requires with_inputs() to have been called first.

```python
>>> import dspy
>>> ex = dspy.Example(question="Why?", answer="Because.").with_inputs("question")
>>> ex.labels()
Example({'answer': 'Because.'}) (input_keys=None)
```

--------------------------------

### Initialize and compile with BetterTogether

Source: https://dspy.ai/current/api/optimizers/BetterTogether

Example showing how to initialize BetterTogether with specific optimizers and compile a student program using a defined strategy.

```python
>>> optimizer = BetterTogether(
...     metric=metric,
...     p=GEPA(metric=metric),
...     w=BootstrapFinetune(metric=metric)
... )
>>> student.set_lm(lm)
>>> compiled = optimizer.compile(
...     student,
...     trainset=trainset,
...     valset=valset,
...     strategy="p -> w"
... )
>>> print(f"Best score: {compiled.candidate_programs[0]['score']}")
```

--------------------------------

### Install faiss-cpu

Source: https://dspy.ai/current/tutorials/rag

Installs the faiss-cpu package (or faiss-gpu if a GPU is available) required for the retriever setup. Alternatively, pass brute_force_threshold=30_000 to dspy.retrievers.Embeddings to avoid faiss.

```python
# %pip install -U faiss-cpu  # or faiss-gpu if you have a GPU
```

--------------------------------

### Install required packages

Source: https://dspy.ai/current/tutorials/yahoo_finance_react

Install the necessary Python packages for the tutorial: dspy, langchain, langchain-community, and yfinance.

```bash
pip install dspy langchain langchain-community yfinance
```

--------------------------------

### View an example AlfWorld task

Source: https://dspy.ai/current/tutorials/games

Initialize an environment session for the first training example and print the task description.

```python
example = trainset[0]

with alfworld.POOL.session() as env:
    task, info = env.init(**example.inputs())

print(task)

```

--------------------------------

### Example: Using KNNFewShot with SentenceTransformer

Source: https://dspy.ai/current/api/optimizers/KNNFewShot

Shows how to initialize KNNFewShot with a sentence transformer embedder, compile a QA module, and use the compiled module. Requires numpy (install with pip install dspy[numpy]).

```python
import dspy
from sentence_transformers import SentenceTransformer

# Define a QA module with chain of thought
qa = dspy.ChainOfThought("question -> answer")

# Create a training dataset with examples
trainset = [
    dspy.Example(question="What is the capital of France?", answer="Paris").with_inputs("question"),
    # ... more examples ...
]

# Initialize KNNFewShot with a sentence transformer model
knn_few_shot = KNNFewShot(
    k=3,
    trainset=trainset,
    vectorizer=dspy.Embedder(SentenceTransformer("all-MiniLM-L6-v2").encode)
)

# Compile the QA module with few-shot learning
compiled_qa = knn_few_shot.compile(qa)

# Use the compiled module
result = compiled_qa("What is the capital of Belgium?")
```

--------------------------------

### Example.inputs() usage

Source: https://dspy.ai/current/api/primitives/Prediction

Shows how to use the inputs() method on an Example. It requires with_inputs to have been called first, otherwise it raises a ValueError.

```python
>>> import dspy
>>> ex = dspy.Example(question="Why?", answer="Because.").with_inputs("question")
>>> ex.inputs()
Example({'question': 'Why?'}) (input_keys={'question'})

```

--------------------------------

### Start MLflow UI

Source: https://dspy.ai/current/tutorials/deployment

Launch the local MLflow tracking server at http://127.0.0.1:5000/.

```bash
> mlflow ui
```

--------------------------------

### Install dspy with Deno extra

Source: https://dspy.ai/current/api/tools/PythonInterpreter

Install DSPy with the Deno extra to get the official Deno Python distribution (>=2.4.5,<3.0.0). This adds 40-50 MiB and supports macOS, glibc Linux, and Windows x86-64.

```bash
pip install "dspy[deno]"

```

--------------------------------

### Install audio dependencies

Source: https://dspy.ai/current/tutorials/audio

Install datasets, soundfile, and PyTorch with CUDA support for audio processing.

```bash
pip install datasets soundfile torch==2.0.1+cu118 torchaudio==2.0.2+cu118

```

--------------------------------

### Zero-shot evaluation output

Source: https://dspy.ai/current/tutorials/games

Example output from the zero-shot evaluation showing the initial task description and environment observation. This is the verbose output printed when the agent starts.

```text
Task: -= Welcome to TextWorld, ALFRED! =-

You are in the middle of a room. Looking quickly around you, you see a countertop 1, a drawer 8, a drawer 7, a drawer 6, a drawer 5, a drawer 4, a drawer 3, a drawer 2, a drawer 1, a garbagecan 1, a handtowelholder 1, a sinkbasin 2, a sinkbasin 1, a toilet 1, a toiletpaperhanger 1, and a towelholder 1.
```

--------------------------------

### Example.inputs() method

Source: https://dspy.ai/current/api/primitives/Example

Returns a new Example containing only the fields marked as inputs. Requires that with_inputs() has been called previously, otherwise it raises a ValueError.

```python
>>> import dspy
>>> ex = dspy.Example(question="Why?", answer="Because.").with_inputs("question")
>>> ex.inputs()
Example({'question': 'Why?'}) (input_keys={'question'})
```

```python
def inputs(self):
    """Return a new `Example` containing only the input fields.

    Requires `with_inputs` to have been called first.

    Raises:
        ValueError: If `with_inputs` was not called on this example.

    Examples:
        >>> import dspy
        >>> ex = dspy.Example(question="Why?", answer="Because.").with_inputs("question")
        >>> ex.inputs()
        Example({'question': 'Why?'}) (input_keys={'question'})
    """
    if self._input_keys is None:
        raise ValueError("Inputs have not been set for this example. Use `example.with_inputs()` to set them.")

    # return items that are in input_keys
    d = {key: self._store[key] for key in self._store if key in self._input_keys}
    # return type(self)(d)
    new_instance = type(self)(base=d)
    new_instance._input_keys = self._input_keys  # Preserve input_keys in new instance
    return new_instance
```

--------------------------------

### Define DSPy signatures for library analysis and code generation

Source: https://dspy.ai/current/tutorials/sample_code_generation

Defines LibraryAnalyzer and CodeGenerator DSPy signatures. LibraryAnalyzer extracts core concepts, patterns, methods, installation info, and code examples from documentation. CodeGenerator produces a working code example, explanation, best practices, and required imports for a specific use case.

```python
class LibraryAnalyzer(dspy.Signature):
    """Analyze library documentation to understand core concepts and patterns."""
    library_name: str = dspy.InputField(desc="Name of the library to analyze")
    documentation_content: str = dspy.InputField(desc="Combined documentation content")

    core_concepts: list[str] = dspy.OutputField(desc="Main concepts and components")
    common_patterns: list[str] = dspy.OutputField(desc="Common usage patterns")
    key_methods: list[str] = dspy.OutputField(desc="Important methods and functions")
    installation_info: str = dspy.OutputField(desc="Installation and setup information")
    code_examples: list[str] = dspy.OutputField(desc="Example code snippets found")

class CodeGenerator(dspy.Signature):
    """Generate code examples for specific use cases using the target library."""
    library_info: str = dspy.InputField(desc="Library concepts and patterns")
    use_case: str = dspy.InputField(desc="Specific use case to implement")
    requirements: str = dspy.InputField(desc="Additional requirements or constraints")

    code_example: str = dspy.OutputField(desc="Complete, working code example")
    explanation: str = dspy.OutputField(desc="Step-by-step explanation of the code")
    best_practices: list[str] = dspy.OutputField(desc="Best practices and tips")
    imports_needed: list[str] = dspy.OutputField(desc="Required imports and dependencies")

```

--------------------------------

### View example from HoVer dataset

Source: https://dspy.ai/current/tutorials/agents

Display a sample example from the training set, showing the claim and the required Wikipedia pages.

```python
example = trainset[0]

print("Claim:", example.claim)
print("Pages that must be retrieved:", example.titles)

```

```text
Claim: This director is known for his work on Miss Potter. The Academy of Motion Picture Arts and Sciences presents the award in which he was nominated for his work in "Babe".
Pages that must be retrieved: ['Miss Potter', 'Chris Noonan', 'Academy Award for Best Director']

```

--------------------------------

### dspy.SIMBA __init__ constructor

Source: https://dspy.ai/current/api/optimizers/SIMBA

Constructor signature for the SIMBA optimizer. Requires numpy; install with `pip install dspy[numpy]`. The `metric` parameter is required and must be a callable that takes an Example and a prediction_dict and returns a float. Defaults: bsize=32, num_candidates=6, max_steps=8, max_demos=4, demo_input_field_maxlen=100_000, temperature_for_sampling=0.2, temperature_for_candidates=0.2. When `prompt_model` is None, the globally configured lm is used.

```python
def __init__(
    self,
    *,
    metric: Callable[[dspy.Example, dict[str, Any]], float],
    bsize: int = 32,
    num_candidates: int = 6,
    max_steps: int = 8,
    max_demos: int = 4,
    prompt_model: dspy.LM | None = None,
    teacher_settings: dict | None = None,
    demo_input_field_maxlen: int = 100_000,
    num_threads: int | None = None,
    temperature_for_sampling: float = 0.2,
    temperature_for_candidates: float = 0.2,
) -> None:
    """
    Initializes SIMBA.
```

--------------------------------

### Create student program for fine-tuning

Source: https://dspy.ai/current/tutorials/games

Creates a student program by deep-copying the optimized teacher and switching its language model to gpt-4o-mini. Optionally, you can reset the demos by uncommenting the line.

```python
student_4o_mini = optimized_4o.deepcopy()
student_4o_mini.set_lm(gpt4o_mini)
# student_4o_mini.react.demos = []  # you can optionally reset the demos

```
Tokens:
Raw