メニュー
DSPy fundamentals from Rust - environment setup, LM configuration, calling DSPy modules, prediction handling
デフォルトでは、最初にソースを確認する Prompt が選択されています。直接コマンドに切り替えるか、ローカルコピーをダウンロードすることもできます。
インストールを決める前に、SKILL.md と SkillsMP に表示されている付属ファイルをお読みください。
Codex または Claude でインストール この Prompt をコピーして Codex、Claude、または他のアシスタントに貼り付けると、Skill ページを確認してインストールできます。
直接コマンドでは確認用 Prompt が省略されます。実行前にソースを確認してください。
npx skills add https://github.com/tools-only/X-Skills --skill rust-pyo3-dspy-fundamentalsコマンドは1行のまま表示されます。コピー前に横へスクロールして全体を確認してください。
ローカルで確認しますか？SkillsMP が現在取得できるファイルをダウンロードできます。
Index of Build Systems Skills
Coordination patterns for distributed dataflow systems including barriers, epochs, and distributed snapshots
Windowing, sessionization, time-series aggregation, and late data handling for streaming systems
SKILL.md を表示中
SOC 職業分類に基づく
| name | rust-pyo3-dspy-fundamentals |
| description | DSPy fundamentals from Rust - environment setup, LM configuration, calling DSPy modules, prediction handling |
| skill_id | rust-pyo3-dspy-fundamentals |
| title | PyO3 DSPy Fundamentals |
| category | rust |
| subcategory | pyo3-dspy |
| complexity | intermediate |
| prerequisites | ["rust-pyo3-fundamentals","rust-pyo3-classes-modules","ml-dspy-setup","ml-dspy-modules"] |
| tags | ["rust","python","pyo3","dspy","llm","ai","integration"] |
| version | 1.0.0 |
| last_updated | "2025-10-30T00:00:00.000Z" |
| learning_outcomes | ["Call DSPy modules from Rust with type safety","Configure language models across the FFI boundary","Handle DSPy predictions and results in Rust","Manage error propagation between languages","Build production-ready DSPy applications in Rust","Optimize performance with proper GIL management"] |
| related_skills | ["rust-pyo3-fundamentals","rust-pyo3-type-conversion-advanced","ml-dspy-modules","ml-dspy-production"] |
| resources | [{"REFERENCE.md (700+ lines)":"Comprehensive guide"},{"3 Python scripts (900+ lines)":"Setup, configuration, inspection"},{"6 Rust+Python examples (1,200+ lines)":"Working code"}] |
Master calling DSPy from Rust using PyO3. Learn to configure language models, execute DSPy modules, handle predictions, and build high-performance, type-safe LLM applications that combine Rust's safety with DSPy's powerful abstractions.
Required:
Recommended:
Ideal for:
Not ideal for:
Install dependencies and validate environment:
# Rust with PyO3
cargo new dspy-rust-app
cd dspy-rust-app
cargo add pyo3 --features extension-module
cargo add tokio --features full
cargo add serde --features derive
cargo add anyhow
# Python with DSPy
python -m venv venv
source venv/bin/activate
pip install dspy-ai openai anthropic
# Validate setup
python skills/rust/pyo3-dspy-fundamentals/resources/scripts/dspy_setup_validator.py
Cargo.toml:
[dependencies]
pyo3 = { version = "0.20", features = ["auto-initialize"] }
src/main.rs:
use pyo3::prelude::*;
use pyo3::types::{PyDict, PyModule};
fn main() -> PyResult<()> {
Python::with_gil(|py| {
// Import DSPy
let dspy = PyModule::import(py, "dspy")?;
// Configure language model
let openai = PyModule::import(py, "dspy")?
.getattr("OpenAI")?
.call1((("gpt-3.5-turbo",),))?;
let settings = dspy.getattr("settings")?;
settings.call_method1("configure", ((openai,),))?;
// Create a simple predictor
let predict = dspy.getattr("Predict")?;
let signature = "question -> answer";
let predictor = predict.call1(((signature,),))?;
// Make prediction
let question = "What is 2+2?";
let result = predictor.call1(((question,),))?;
// Extract answer
let answer: String = result
.getattr("answer")?
.extract()?;
println!("Question: {}", question);
println!("Answer: {}", answer);
Ok(())
})
}
Run:
export OPENAI_API_KEY="your-key"
cargo run
Structured Configuration (recommended):
use pyo3::prelude::*;
use serde::{Deserialize, Serialize};
#[derive(Debug, Serialize, Deserialize)]
struct LMConfig {
provider: String, // "openai", "anthropic", "cohere"
model: String,
temperature: f32,
max_tokens: usize,
}
impl LMConfig {
fn configure_dspy(&self, py: Python) -> PyResult<()> {
let dspy = PyModule::import(py, "dspy")?;
let lm = match self.provider.as_str() {
"openai" => {
dspy.getattr("OpenAI")?.call1((
(self.model.as_str(),),
))?
},
"anthropic" => {
dspy.getattr("Anthropic")?.call1((
(self.model.as_str(),),
))?
},
_ => return Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(
format!("Unsupported provider: {}", self.provider)
)),
};
dspy.getattr("settings")?
.call_method1("configure", ((lm,),))?;
Ok(())
}
}
fn main() -> PyResult<()> {
let config = LMConfig {
provider: "openai".to_string(),
model: "gpt-3.5-turbo".to_string(),
temperature: 0.7,
max_tokens: 500,
};
Python::with_gil(|py| {
config.configure_dspy(py)?;
// Now ready to use DSPy modules
Ok(())
})
}
Use helper script:
# Generate config from environment
python resources/scripts/lm_config_manager.py generate > config.json
# Validate config
python resources/scripts/lm_config_manager.py validate config.json
Calling ChainOfThought:
use pyo3::prelude::*;
use pyo3::types::PyDict;
#[derive(Debug)]
struct Prediction {
answer: String,
reasoning: Option<String>,
}
fn call_chain_of_thought(
py: Python,
question: &str,
) -> PyResult<Prediction> {
let dspy = PyModule::import(py, "dspy")?;
// Create ChainOfThought predictor
let cot = dspy.getattr("ChainOfThought")?;
let signature = "question -> answer";
let predictor = cot.call1(((signature,),))?;
// Make prediction
let result = predictor.call1(((question,),))?;
// Extract fields
let answer: String = result.getattr("answer")?.extract()?;
let reasoning: Option<String> = result
.getattr("reasoning")
.ok()
.and_then(|r| r.extract().ok());
Ok(Prediction { answer, reasoning })
}
fn main() -> PyResult<()> {
Python::with_gil(|py| {
// Configure DSPy first
configure_lm(py)?;
let prediction = call_chain_of_thought(
py,
"Explain the theory of relativity in simple terms"
)?;
println!("Answer: {}", prediction.answer);
if let Some(reasoning) = prediction.reasoning {
println!("Reasoning: {}", reasoning);
}
Ok(())
})
}
Define in Python (recommended for complex modules):
# dspy_modules.py
import dspy
class QAWithContext(dspy.Module):
def __init__(self):
super().__init__()
self.generate = dspy.ChainOfThought("context, question -> answer")
def forward(self, context, question):
return self.generate(context=context, question=question)
Call from Rust:
use pyo3::prelude::*;
use pyo3::types::PyModule;
fn call_custom_module(
py: Python,
context: &str,
question: &str,
) -> PyResult<String> {
// Import custom module
let module = PyModule::from_code(
py,
include_str!("dspy_modules.py"),
"dspy_modules.py",
"dspy_modules",
)?;
let qa_class = module.getattr("QAWithContext")?;
let qa_instance = qa_class.call0()?;
// Call forward
let result = qa_instance.call_method1(
"forward",
((context, question),)
)?;
let answer: String = result.getattr("answer")?.extract()?;
Ok(answer)
}
Robust Error Handling Pattern:
use anyhow::{Context, Result};
use pyo3::prelude::*;
#[derive(Debug, thiserror::Error)]
enum DSpyError {
#[error("Python error: {0}")]
Python(#[from] PyErr),
#[error("DSPy module error: {0}")]
Module(String),
#[error("Configuration error: {0}")]
Config(String),
#[error("Prediction failed: {0}")]
Prediction(String),
}
fn safe_dspy_call(question: &str) -> Result<String> {
Python::with_gil(|py| {
let dspy = PyModule::import(py, "dspy")
.context("Failed to import DSPy")?;
let predict = dspy.getattr("Predict")
.context("Failed to get Predict class")?;
let predictor = predict.call1((("question -> answer",),))
.context("Failed to create predictor")?;
let result = predictor.call1(((question,),))
.context("Prediction failed")?;
let answer: String = result.getattr("answer")?
.extract()
.context("Failed to extract answer")?;
Ok(answer)
})
}
fn main() {
match safe_dspy_call("What is Rust?") {
Ok(answer) => println!("Answer: {}", answer),
Err(e) => eprintln!("Error: {:?}", e),
}
}
GIL Management:
use pyo3::prelude::*;
use std::sync::Arc;
// Store Python objects across GIL releases
struct DSpyPredictor {
predictor: Py<PyAny>,
}
impl DSpyPredictor {
fn new(signature: &str) -> PyResult<Self> {
Python::with_gil(|py| {
let dspy = PyModule::import(py, "dspy")?;
let predict = dspy.getattr("Predict")?;
let predictor = predict.call1(((signature,),))?;
Ok(Self {
predictor: predictor.into(),
})
})
}
fn predict(&self, question: &str) -> PyResult<String> {
Python::with_gil(|py| {
let result = self.predictor
.as_ref(py)
.call1(((question,),))?;
result.getattr("answer")?.extract()
})
}
}
// Use across multiple threads
fn parallel_predictions(questions: Vec<String>) -> Vec<PyResult<String>> {
let predictor = Arc::new(
DSpyPredictor::new("question -> answer").unwrap()
);
questions.into_iter()
.map(|q| {
let pred = Arc::clone(&predictor);
// Each thread acquires GIL independently
pred.predict(&q)
})
.collect()
}
Service Structure:
use pyo3::prelude::*;
use std::sync::Arc;
use tokio::sync::Mutex;
pub struct DSpyService {
predictor: Arc<Mutex<Py<PyAny>>>,
}
impl DSpyService {
pub fn new(signature: &str) -> PyResult<Self> {
let predictor = Python::with_gil(|py| {
let dspy = PyModule::import(py, "dspy")?;
let predict = dspy.getattr("Predict")?;
let pred = predict.call1(((signature,),))?;
Ok::<_, PyErr>(pred.into())
})?;
Ok(Self {
predictor: Arc::new(Mutex::new(predictor)),
})
}
pub async fn predict(&self, input: String) -> PyResult<String> {
let predictor = self.predictor.lock().await;
Python::with_gil(|py| {
let result = predictor.as_ref(py).call1(((input,),))?;
result.getattr("answer")?.extract()
})
}
}
#[tokio::main]
async fn main() -> PyResult<()> {
let service = DSpyService::new("question -> answer")?;
let answer = service.predict(
"What is machine learning?".to_string()
).await?;
println!("Answer: {}", answer);
Ok(())
}
Comprehensive 700+ line guide covering:
Load: Read pyo3-dspy-fundamentals/resources/REFERENCE.md
1. dspy_setup_validator.py (~300 lines)
Usage:
python resources/scripts/dspy_setup_validator.py
python resources/scripts/dspy_setup_validator.py --fix # Auto-fix issues
2. lm_config_manager.py (~300 lines)
Usage:
# Generate config
python resources/scripts/lm_config_manager.py generate > config.json
# Validate
python resources/scripts/lm_config_manager.py validate config.json
# Test connection
python resources/scripts/lm_config_manager.py test config.json
3. module_inspector.py (~300 lines)
Usage:
# Inspect module
python resources/scripts/module_inspector.py inspect QAModule
# Generate Rust types
python resources/scripts/module_inspector.py codegen QAModule > types.rs
1. hello-world/ - Minimal DSPy call
2. basic-qa/ - Question answering
3. lm-configuration/ - Configure providers
4. error-handling/ - Robust error handling
5. module-state/ - Stateful modules
6. benchmarking/ - Performance measurement
✅ Release GIL during CPU-bound Rust work ✅ Validate inputs before crossing language boundary ✅ Use anyhow/thiserror for rich error context ✅ Cache Python objects (Py) to avoid repeated imports ✅ Test error paths thoroughly ✅ Profile GIL acquisition patterns ✅ Document Python version requirements
❌ Hold GIL longer than necessary ❌ Panic in Rust code called from Python ❌ Assume Python objects are thread-safe ❌ Forget to handle Python exceptions ❌ Mix Python and Rust error handling ❌ Skip environment validation ❌ Ignore memory leaks across FFI boundary
Problem: Holding GIL while waiting for Rust work
// ❌ Bad: GIL held during expensive work
Python::with_gil(|py| {
let result = predictor.call()?;
expensive_rust_computation(&result); // GIL still held!
Ok(())
})
Solution: Release GIL during Rust work
// ✅ Good: Release GIL
let result = Python::with_gil(|py| {
predictor.call()
})?;
// GIL released here
expensive_rust_computation(&result);
Problem: Python objects not properly released
// ❌ Bad: Py<PyAny> not dropped
let mut cache: Vec<Py<PyAny>> = Vec::new();
// cache grows forever
Solution: Explicit cleanup
// ✅ Good: Clear cache periodically
if cache.len() > 1000 {
Python::with_gil(|py| {
cache.clear(); // Properly drops Python refs
});
}
Problem: Silent Python exceptions
// ❌ Bad: Exception lost
let _ = predictor.call();
Solution: Propagate errors properly
// ✅ Good: Handle or propagate
match predictor.call() {
Ok(result) => process(result),
Err(e) => {
eprintln!("DSPy error: {}", e);
return Err(e.into());
}
}
Symptom: ModuleNotFoundError: No module named 'dspy'
Solution:
# Ensure Python environment activated
source venv/bin/activate
# Install DSPy
pip install dspy-ai
# Verify
python -c "import dspy; print(dspy.__version__)"
Symptom: PanicException: GIL is not held
Solution: All Python calls must be in with_gil block:
Python::with_gil(|py| {
// All Python operations here
})
Symptom: Rust code crashes with segmentation fault
Solutions:
with_gilRUST_BACKTRACE=1After mastering fundamentals:
Version: 1.0.0 Last Updated: 2025-10-30 Maintainer: DSPy-PyO3 Integration Team