What is Superlinked?
Superlinked is an open-source compute framework (Apache 2.0) designed to transform complex data into vector embeddings for RAG, semantic search, recommendation systems, and analytics.
The project was built by the team at superlinked.com, led by CEO Daniel Svonava and co-founder Ben Gutkovich, with backing from Index Ventures.
The journey from Superlinked → SIE
Superlinked was originally created as a Python framework to combine metadata with unstructured data (text, image) into multi-modal vectors. However, the team realized that the biggest pain point in production is inference — running embedding models efficiently at scale.
Therefore, Superlinked pivoted and introduced Superlinked Inference Engine (SIE): a specialized open-source inference server. Repo superlinked/superlinked (43 stars) was archived in May 2026 and redirected to superlinked/sie (2.2k stars).
This article will overview both: the Superlinked framework architecture and the inherited SIE inference engine.
Superlinked Framework architecture (declarative DAG)
The Superlinked framework is built on a declarative DAG (Directed Acyclic Graph) architecture. Four main building blocks:
1. Schema
Declares data structure and field types. Supports IdField, String, Integer, Float, and other complex types.
class Product(sl.Schema):
id: sl.IdField
description: sl.String
rating: sl.Integer
2. Space
Defines how a field is transformed into a vector. Types of space:
- TextSimilaritySpace — uses sentence-transformers to embedding text
- NumberSpace — numbers (min-max or similarity mode)
- CategoricalSpace — categories as one-hot or embedding
- RecencySpace — time (recent = high weight)
- ImageSpace — uses OpenCLIP image embedding
description_space = sl.TextSimilaritySpace(
text=product.description, model="Alibaba-NLP/gte-large-en-v1.5"
)
rating_space = sl.NumberSpace(
number=product.rating, min_value=1, max_value=5, mode=sl.Mode.MAXIMUM
)
3. Index
Aggregate multiple Spaces into a single vector via ConcatenationNode (vector concatenation) and AggregationNode (weighted aggregation). Index manages persistence and event-based updates.
index = sl.Index([description_space, rating_space], fields=[product.rating])
4. Query
Search logic definitions: similarity search, hard filtering, dynamic weights, and Natural Language Query (use LLM to extract parameters from natural language queries).
query = (
sl.Query(index, weights={
description_space: sl.Param("description_weight"),
rating_space: sl.Param("rating_weight"),
})
.find(product)
.similar(description_space, sl.Param("description_query"))
.limit(sl.Param("limit"))
.with_natural_query(
sl.Param("natural_language_query"),
sl.OpenAIClientConfig(api_key=os.environ["OPEN_AI_API_KEY"], model="gpt-4o")
)
)
Working mechanism
Online Ingestion DAG
When data is ingested via source.put(data), OnlineSchemaDagCompiler compile DAG into OnlineSchemaDag, passing through nodes:
- Chunking → Embedding (using
SentenceTransformerManagerorModalEngine) → Aggregation → Concatenation → Index → VDB write.
Embedding engine has a mechanism DelayedEvaluator merge multiple requests for batch inference to increase throughput when using remote GPU.
Query DAG
Query is compiled separately by QueryDagCompiler, skip unnecessary nodes at query-time (such as ChunkingNode, ComparisonFilterNode). Only keep nodes required for vector calculation and similarity search.
From prototype to production
Superlinked provides 2 executors:
| Executor | Purpose | Storage |
|---|---|---|
InMemoryExecutor |
Rapid development and testing | In-memory |
RestExecutor |
Production | Redis, Qdrant, MongoDB, TopK |
Just change the executor, the entire code remains unchanged — unifying evaluation, ingestion, and serving stack.
Superlinked Inference Engine (SIE)
The evolution of Superlinked, focusing on self-hosted inference for agents. SIE is an inference server/cluster running 100+ models via a single API, OpenAI API compatible.
SIE Architecture
- Gateway load-balancing — distributing requests to workers
- KEDA autoscaling — scale-to-zero when not in use
- Grafana dashboards — observe the entire cluster
- LRU eviction — load/unload models on demand
- Support for GPU (CUDA) and Apple Silicon (MLX)
SIE supported tasks
| Task | Models |
|---|---|
| Search | bge-m3, splade-v3, colbertv2, qwen3-reranker |
| Document → Markdown | glm-ocr, mineru, paddleocr-vl, docling |
| Structured output | gliner2, nuner-zero, qwen3.6-27b |
| Content safety | granite-guardian-2b |
| Agent loop | qwen3.6-27b (open LLM) |
Quickstart SIE
pip install "sie-server[local]" && sie-server serve
# Hoặc Docker với GPU
docker run --gpus all -p 8080:8080 \
-v sie-hf-cache:/app/.cache/huggingface \
ghcr.io/superlinked/sie-server:latest-cuda12-default
OpenAI-compatible API:
curl http://localhost:8080/v1/embeddings \
-H 'Content-Type: application/json' \
-d '{"model": "sentence-transformers/all-MiniLM-L6-v2", "input": "Hello world"}'
Ecosystem integration
SIE comes pre-integrated with: LangChain, LlamaIndex, Haystack, DSPy, CrewAI, Chroma, Qdrant, Weaviate, LanceDB.
Provides MCP server for Claude and MCP clients: offload document processing (OCR, extraction, summarization) from frontier-model bill.
Superlinked vs LangChain/LlamaIndex
| Criteria | Superlinked | LangChain / LlamaIndex |
|---|---|---|
| Specialization | Vector compute (chunk, embed, search) | General-purpose LLM framework |
| Architecture | Declarative DAG | Chain / Pipeline |
| Dynamic weights | First-class citizen | Need custom reranker |
| Multi-modal | Text + Image + Number + Category + Time | Primarily text |
| Inference server | SIE (self-hosted, 100+ models) | Third-party dependency |
Conclusion
Superlinked (and SIE inheritance) solves a very practical problem: vector compute and inference for AI search/agent in productionIf you are building a RAG, semantic search, or recommendation system that needs to combine multiple data types (text, numbers, time, images), Superlinked is a choice worth considering — especially when query-time weighting is a core requirement, not a workaround.
With SIE, you can self-host the entire inference stack (embedding, reranking, OCR, generation) without depending on third-party APIs, keeping data entirely within your cloud or air-gapped environment.
Links:
