Hacktoberfest 2026: los issues que los mantenedores marcaron para octubre, abiertos y aptos para principiantes. Explorar issues de Hacktoberfest

Feature: DakeraMemoryStore — decay-weighted persistent memory backend for SK Memory

Abierto
  • ¿Algo no está bien?
#14,130 0 comentarios 0 reacciones 0 asignados Ver en GitHub

Los mantenedores suelen responder en 2 días

Nadie ha tomado este issue todavía.

Evaluación

Dificultad
5/5
Tiempo estimado
Más de una semana
Aptitud para principiantes
38/100
Tipo de issue
Nueva funcionalidad
Claridad
Bastante claro
Estado de actividad
Tranquilo
Stack tecnológico
docker, python
Área
ai, backend

Línea de trabajo

Comience con python/semantic_kernel/memory/memory_store_base.py y compare python/semantic_kernel/memory/volatile_memory_store.py con los conectores de python/semantic_kernel/connectors/memory/. Determine el contrato completo de MemoryStoreBase y cómo se espera que se comporte el cliente de Dakera. Se considera terminado cuando exista un DakeraMemoryStore completo que cubra las operaciones de memoria propuestas y cuya integración y compatibilidad con la interfaz existente hayan sido verificadas.

Escrito por el modelo de indexación a partir del texto del issue.

Descripción

Summary

Semantic Kernel's memory system accepts pluggable IMemoryStore implementations (Python: MemoryStoreBase). This issue proposes a DakeraMemoryStore that brings decay-weighted, cross-session persistence to SK agents without requiring Weaviate, Azure AI Search, or other heavy vector database deployments.

Problem

SK's built-in memory stores (volatile in-process, SQLite) lose all data on restart. Connecting to Azure AI Search or Weaviate adds cost and infrastructure complexity for teams that want persistent agent memory. None of the existing backends implement relevance decay — a stale memory from 3 months ago ranks as high as one from yesterday.

Proposed Solution

A DakeraMemoryStore implementing SK's memory interface:

from semantic_kernel.memory.memory_store_base import MemoryStoreBase
from semantic_kernel.memory.memory_record import MemoryRecord
from dakera import DakeraClient

class DakeraMemoryStore(MemoryStoreBase):
    """Dakera-backed SK memory store with decay-weighted recall.
    
    Setup: docker run -d -p 3300:3300 -e DAKERA_API_KEY=demo ghcr.io/dakera-ai/dakera:latest
    """
    
    def __init__(self, base_url: str = "http://localhost:3300", api_key: str = ""):
        self._client = DakeraClient(base_url=base_url, api_key=api_key)
    
    async def get_nearest_matches_async(
        self,
        collection_name: str,
        embedding: ndarray,
        limit: int,
        min_relevance_score: float = 0.0,
        with_embeddings: bool = False,
    ) -> List[Tuple[MemoryRecord, float]]:
        response = await self._client.recall_async(
            agent_id=collection_name,
            query=embedding.tolist(),
            top_k=limit,
        )
        return [
            (self._to_memory_record(m), m.score)
            for m in (response.memories if response else [])
            if m.score >= min_relevance_score
        ]
    
    async def upsert_async(self, collection_name: str, record: MemoryRecord) -> str:
        return await self._client.store_memory_async(
            agent_id=collection_name,
            content=record.text,
            metadata={"id": record.id, **record.additional_metadata},
        )
    
    # ... get_async, remove_async, get_collections_async

Usage with the SK kernel:

import semantic_kernel as sk

kernel = sk.Kernel()
kernel.add_memory_store(DakeraMemoryStore(
    base_url="http://localhost:3300",
    api_key="demo",
))

# Store and recall work as normal
await kernel.memory.save_information_async("user-profile", id="pref1", text="prefers concise answers")
results = await kernel.memory.search_async("user-profile", "response style", limit=3)

Why Dakera vs Azure AI Search / Weaviate

Azure AI Search Weaviate Dakera
Decay weighting ❌ ❌ ✅
Self-hosted ❌ (cloud) ✅ (complex) ✅ (1 container)
Cost Per-query billing Infrastructure Free self-hosted
Session isolation Manual Manual Built-in
Setup complexity High (portal + keys) Medium Low (single Docker cmd)

Key Differentiator: Decay Weighting

Dakera assigns time-based and access-frequency decay weights to each memory. When SK agents search memory, results ranked by recency and access patterns — not just semantic similarity. Stale context from months ago won't pollute current task context.

Setup

docker run -d -p 3300:3300 -e DAKERA_API_KEY=demo ghcr.io/dakera-ai/dakera:latest
pip install dakera

Relevant Files

  • python/semantic_kernel/memory/memory_store_base.py — abstract interface
  • python/semantic_kernel/memory/volatile_memory_store.py — reference implementation
  • python/semantic_kernel/connectors/memory/ — existing third-party connectors

Happy to open a PR with the full implementation across Python and optionally C# (.NET) variants.

Lenguaje dominante
C#
Estrellas
28.6k
Forks
4.8k
Merge medio
12 h 20 min
PR fusionados (30 d)
12

Preparar el entorno

Primeros pasos

  1. Lee el issue completo y luego la guía de contribución del proyecto.
  2. Comenta en el issue que vas a ocuparte — evita que dos personas hagan lo mismo.
  3. Haz un fork del repositorio y trabaja en una rama.
  4. Abre un pull request que haga referencia al número del issue.

Más de microsoft/semantic-kernel

Todos los issues de microsoft/semantic-kernel

Issues similares

Más issues de C#

Recibe los nuevos issues en tu correo

Un resumen breve de issues de GitHub para principiantes.