Add self-hosted Dakera memory connector — community package following CONTRIBUTING guidance

[ferhimedamine]

Overview

Semantic Kernel's CONTRIBUTING.md explicitly states: "we won't be directly adding hosting for [memory connectors] within the Semantic Kernel repository." This discussion proposes exactly what CONTRIBUTING recommends: a standalone community package semantic-kernel-dakera that integrates Dakera — a self-hosted, decay-weighted vector memory server.

What Dakera provides

Dakera is a self-hosted memory server (Docker, REST API, MCP protocol). Unlike cloud connectors (Azure AI Search, Qdrant Cloud, Pinecone), Dakera runs entirely on your infrastructure:

docker run -p 3000:3000 -e DAKERA_API_KEY=your-key dakera/dakera:latest

Published packages: dakera (PyPI 0.12.8), @dakera-ai/dakera (npm 0.11.100), dakera-client (crates.io)

Proposed implementation pattern

Following the existing connector structure in python/semantic_kernel/connectors/ (e.g., redis.py, chroma.py, qdrant.py):

# In standalone package: semantic_kernel_dakera/connector.py
from semantic_kernel.connectors.memory.base import MemoryStoreBase
from semantic_kernel.utils.settings import KernelBaseSettings

class DakeraSettings(KernelBaseSettings):
    """Dakera connector settings, loaded from env vars with DAKERA_ prefix."""
    env_prefix = "DAKERA_"
    api_url: str = "http://localhost:3000"
    api_key: str = ""
    top_k: int = 5

class DakeraMemoryStore(MemoryStoreBase):
    """Memory store backed by a self-hosted Dakera server.

    Self-host: docker run -p 3000:3000 dakera/dakera:latest
    Install: pip install semantic-kernel-dakera
    """

    def __init__(self, settings: DakeraSettings | None = None):
        self._settings = settings or DakeraSettings()

    async def upsert_async(self, collection: str, record: MemoryRecord) -> str:
        async with httpx.AsyncClient() as c:
            resp = await c.post(
                f"{self._settings.api_url}/v1/memories",
                headers={"Authorization": f"Bearer {self._settings.api_key}"},
                json={
                    "content": record.text,
                    "agent_id": collection,
                    "metadata": record.additional_metadata,
                },
            )
            resp.raise_for_status()
        return resp.json()["id"]

    async def get_nearest_matches_async(
        self,
        collection: str,
        embedding: ndarray,
        limit: int,
        min_relevance_score: float = 0.0,
        with_embeddings: bool = False,
    ) -> list[tuple[MemoryRecord, float]]:
        async with httpx.AsyncClient() as c:
            resp = await c.post(
                f"{self._settings.api_url}/v1/memories/search",
                headers={"Authorization": f"Bearer {self._settings.api_key}"},
                json={"query": "", "vector": embedding.tolist(), "agent_id": collection, "top_k": limit},
            )
        results = resp.json().get("results", [])
        return [
            (MemoryRecord(id=r["id"], text=r["content"], ...), r["score"])
            for r in results
            if r["score"] >= min_relevance_score
        ]

Usage:

from semantic_kernel import Kernel
from semantic_kernel_dakera import DakeraMemoryStore, DakeraSettings

kernel = Kernel()
kernel.add_memory_store(DakeraMemoryStore(DakeraSettings(
    api_url="http://localhost:3000",
    api_key="dk_your_key",
)))

Questions for the maintainers

1. Is a standalone semantic-kernel-dakera package the right path (vs. a community extras contrib PR)?
2. Is MemoryStoreBase still the correct base class, or should this use the newer VectorStoreCollection abstraction?
3. Would this be listed in the SK documentation under community connectors once published?

We have a complete implementation ready to publish. Just want to confirm the preferred approach before we finalize the package structure.