---
title: DSPy
description: Use SIE embeddings in DSPy programs for retrieval-augmented generation.
canonical_url: https://superlinked.com/docs/integrations/dspy
last_updated: 2026-05-18
---

The `sie-dspy` package provides DSPy-compatible modules for SIE: dense and sparse embedders, a reranker, and an extractor supporting entities, relations, classifications, and object detection.

## Installation

```bash
pip install sie-dspy
```

This installs `sie-sdk` and `numpy` as dependencies.

## Start the Server

Source: [packages/sie_server/src/sie_server/cli.py](https://github.com/superlinked/sie/blob/main/packages/sie_server/src/sie_server/cli.py)

```bash
# Docker (recommended)
docker run -p 8080:8080 ghcr.io/superlinked/sie-server:latest-cpu-default

# Or with GPU
docker run --gpus all -p 8080:8080 ghcr.io/superlinked/sie-server:latest-cuda12-default
```

## Embedder

Source: [integrations/sie_dspy/src/sie_dspy/embedder.py](https://github.com/superlinked/sie/blob/main/integrations/sie_dspy/src/sie_dspy/embedder.py)

`SIEEmbedder` is callable and works directly with DSPy's retrieval components.

```python
from sie_dspy import SIEEmbedder

embedder = SIEEmbedder(
    base_url="http://localhost:8080",
    model="BAAI/bge-m3",
)

# Embed a single text
vector = embedder("What is machine learning?")
print(vector.shape)  # (1024,)

# Embed multiple texts
vectors = embedder(["First document", "Second document"])
print(vectors.shape)  # (2, 1024)
```

### Configuration Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `base_url` | `str` | `http://localhost:8080` | SIE server URL |
| `model` | `str` | `BAAI/bge-m3` | Model to use |
| `gpu` | `str` | `None` | Target GPU type for routing |
| `options` | `dict` | `None` | Model-specific options |
| `timeout_s` | `float` | `180.0` | Request timeout in seconds |

## Full Example

Source: [integrations/sie_dspy/src/sie_dspy/embedder.py](https://github.com/superlinked/sie/blob/main/integrations/sie_dspy/src/sie_dspy/embedder.py)

Build a complete DSPy RAG program using SIE embeddings:

```python
import dspy
from sie_dspy import SIEEmbedder

# 1. Configure DSPy with your LLM
lm = dspy.LM("openai/gpt-4o-mini")
dspy.configure(lm=lm)

# 2. Create SIE embedder
embedder = SIEEmbedder(
    base_url="http://localhost:8080",
    model="BAAI/bge-m3",
)

# 3. Build retriever with your corpus
corpus = [
    "Machine learning is a branch of artificial intelligence.",
    "Neural networks are inspired by biological neurons.",
    "Deep learning uses multiple layers of neural networks.",
    "Python is popular for machine learning development.",
]

retriever = dspy.retrievers.Embeddings(
    corpus=corpus,
    embedder=embedder,
    k=2,
)

# 4. Define a RAG signature
class RAG(dspy.Signature):
    """Answer questions using retrieved context."""
    context: list[str] = dspy.InputField(desc="retrieved passages")
    question: str = dspy.InputField()
    answer: str = dspy.OutputField()

# 5. Build the RAG program
class RAGProgram(dspy.Module):
    def __init__(self):
        self.retriever = retriever
        self.generate = dspy.ChainOfThought(RAG)

    def forward(self, question: str):
        passages = self.retriever(question)
        return self.generate(context=passages, question=question)

# 6. Run the program
rag = RAGProgram()
result = rag("What is deep learning?")
print(result.answer)
```

## Sparse Embeddings

Source: [integrations/sie_dspy/src/sie_dspy/embedder.py](https://github.com/superlinked/sie/blob/main/integrations/sie_dspy/src/sie_dspy/embedder.py)

`SIESparseEmbedder` provides sparse vectors for hybrid search workflows.

```python
from sie_dspy import SIEEmbedder, SIESparseEmbedder

dense_embedder = SIEEmbedder(model="BAAI/bge-m3")
sparse_embedder = SIESparseEmbedder(model="BAAI/bge-m3")

# Index corpus - store both in your vector DB (Qdrant, Weaviate, etc.)
dense_vecs = dense_embedder(corpus)
sparse_vecs = sparse_embedder.embed_documents(corpus)

# Query
dense_query = dense_embedder(query)
sparse_query = sparse_embedder.embed_query(query)
```

### Configuration Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `base_url` | `str` | `http://localhost:8080` | SIE server URL |
| `model` | `str` | `BAAI/bge-m3` | Model to use |
| `gpu` | `str` | `None` | Target GPU type for routing |
| `options` | `dict` | `None` | Model-specific options |
| `timeout_s` | `float` | `180.0` | Request timeout in seconds |

## Reranking

Source: [integrations/sie_dspy/src/sie_dspy/modules.py](https://github.com/superlinked/sie/blob/main/integrations/sie_dspy/src/sie_dspy/modules.py)

`SIEReranker` is a `dspy.Module` that reranks passages by relevance to a query using a cross-encoder model.

```python
from sie_dspy import SIEReranker

reranker = SIEReranker(
    base_url="http://localhost:8080",
    model="jinaai/jina-reranker-v2-base-multilingual",
)

result = reranker(
    query="What is machine learning?",
    passages=["ML learns from data.", "Weather is sunny.", "Deep learning uses neural nets."],
    k=2,
)

print(result.passages)  # Top 2 most relevant passages
print(result.scores)    # Corresponding relevance scores
```

### Configuration Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `base_url` | `str` | `http://localhost:8080` | SIE server URL |
| `model` | `str` | `jinaai/jina-reranker-v2-base-multilingual` | Reranker model |
| `gpu` | `str` | `None` | Target GPU type for routing |
| `options` | `dict` | `None` | Model-specific options |
| `timeout_s` | `float` | `180.0` | Request timeout in seconds |

## Extraction

Source: [integrations/sie_dspy/src/sie_dspy/modules.py](https://github.com/superlinked/sie/blob/main/integrations/sie_dspy/src/sie_dspy/modules.py)

`SIEExtractor` is a `dspy.Module` that extracts structured data from text. It supports all extraction types: entities (GLiNER), relations (GLiREL), classifications (GLiClass), and object detection (GroundingDINO/OWL-v2). The `forward()` method returns a `dspy.Prediction` with `entities`, `relations`, `classifications`, and `objects` fields (plus `_dict` variants for JSON serialization).

### Entity Extraction

```python
from sie_dspy import SIEExtractor

extractor = SIEExtractor(
    base_url="http://localhost:8080",
    model="urchade/gliner_multi-v2.1",
    labels=["person", "organization", "location"],
)

result = extractor(text="Tim Cook announced new products at Apple Park in Cupertino.")

for entity in result.entities:
    print(f"{entity.label}: {entity.text} ({entity.score:.2f})")
# person: Tim Cook (0.96)
# organization: Apple (0.91)
# location: Cupertino (0.88)

# Also available as dicts for JSON serialization
print(result.entities_dict)
```

### Relation Extraction

Extract relationships between entities using GLiREL:

```python
from sie_dspy import SIEExtractor

extractor = SIEExtractor(
    base_url="http://localhost:8080",
    model="jackboyla/glirel-large-v0",
    labels=["works_for", "ceo_of", "founded"],
)

result = extractor(text="Tim Cook is the CEO of Apple Inc.")

for relation in result.relations:
    print(f"{relation.head} --{relation.relation}--> {relation.tail}")
# Tim Cook --ceo_of--> Apple Inc.

# Also available as dicts
print(result.relations_dict)
```

### Text Classification

Classify text into categories using GLiClass:

```python
from sie_dspy import SIEExtractor

extractor = SIEExtractor(
    base_url="http://localhost:8080",
    model="knowledgator/gliclass-base-v1.0",
    labels=["positive", "negative", "neutral"],
)

result = extractor(text="I absolutely loved this movie! The acting was superb.")

for classification in result.classifications:
    print(f"{classification.label}: {classification.score:.2f}")
# positive: 0.94
# neutral: 0.04
# negative: 0.02

# Also available as dicts
print(result.classifications_dict)
```

### Configuration Options

The extraction model determines which result fields are populated.

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `base_url` | `str` | `http://localhost:8080` | SIE server URL |
| `model` | `str` | `urchade/gliner_multi-v2.1` | Extraction model (GLiNER, GLiREL, GLiClass, GroundingDINO, OWL-v2) |
| `labels` | `list[str]` | `["person", "organization", "location"]` | Labels for extraction (entity types, relation types, or classification categories) |
| `gpu` | `str` | `None` | Target GPU type for routing |
| `options` | `dict` | `None` | Model-specific options |
| `timeout_s` | `float` | `180.0` | Request timeout in seconds |

## What's Next

- [Encode Text](/docs/encode/) - embedding API details
- [Score / Rerank](/docs/score/) - reranking details
- [Extract](/docs/extract/) - extraction details (NER, relations, classification, vision)
- [Model Catalog](/models) - all supported models
- [Troubleshooting](/docs/reference/troubleshooting/) - common errors and solutions