New Feature: GoodMem Memory Connector - centralized memory API for agents

[MuaazWahid]

---

name: GoodMem Memory Connector
about: Simplify agentic memory management in Semantic Kernel by powering agents with Good Memory.

---

Before an agent can remember anything, developers have to manage embedding services, models, and dimensions across collections.

GoodMem removes that entire setup. Send text in, get semantically relevant results back (embedding pipeline included). GoodMem is a lightning-fast memory API for AI agents to easily read & write persistent memory for AI systems.

without GoodMem

# 1. Pick, configure, and maintain an embedding service
embedding_service = OpenAITextEmbedding(
    ai_model_id="text-embedding-3-small",
    api_key=OPENAI_API_KEY
)

# 2. Stand up a vector store and wire in the embedder
store = InMemoryVectorStore(embedding_service=embedding_service)
collection = store.get_collection("agent-memory", record_type=Memory)

# 3. Manually ensure embedding dimensions match your model
# 4. Begin to write agent logic

with GoodMem

async with GoodMemCollection(record_type=Memory, collection_name="agent-memory") as collection:
    await collection.upsert(memory_list)
    agent = ChatCompletionAgent(
        name="MemoryAgent",
        service=OpenAIChatCompletion(ai_model_id=openai_model),
        instructions=("Always search memory before answering factual questions."),
        function_choice_behavior=FunctionChoiceBehavior.Auto(),
        plugins=[collection.as_plugin(name="memory")],
    )

https://github.com/PAIR-Systems-Inc/goodmem-semantic-kernel
https://goodmem.ai/

[moonbox3]

Thanks for the suggestion @MuaazWahid. We appreciate you thinking about ways to simplify the developer experience.

That said, Semantic Kernel's vector store abstractions already provide the streamlined experience you're describing. The "before" example in the issue doesn't reflect the current state of our APIs.

Here's what the equivalent SK code actually looks like today:

@vectorstoremodel
@dataclass
class Memory:
    id: Annotated[str, VectorStoreField("key")]
    content: Annotated[str, VectorStoreField("data")]
    embedding: Annotated[
        list[float] | str | None,
        VectorStoreField("vector", dimensions=1536, embedding_generator=OpenAITextEmbedding()),
    ] = None

    def __post_init__(self):
        if self.embedding is None:
            self.embedding = self.content

async with InMemoryCollection[str, Memory](record_type=Memory) as collection:
    await collection.upsert(memory_list)  # embeddings generated automatically

    kernel.add_function(
        "memory",
        collection.create_search_function(
            function_name="recall",
            description="Search agent memory.",
            string_mapper=lambda x: x.record.content,
        ),
    )

    agent = ChatCompletionAgent(
        name="MemoryAgent",
        kernel=kernel,
        instructions="Always search memory before answering factual questions.",
        function_choice_behavior=FunctionChoiceBehavior.Auto(),
    )

Key things to note:

• Embedding generation is automatic — declare an embedding_generator on the field (or pass one to the collection), and embeddings are generated transparently on both upsert and search. No manual dimension management needed.
• Plugin exposure is built-in — create_search_function() returns a KernelFunction you can add directly to the kernel, which is equivalent to the as_plugin() pattern shown in your example.
• Any vector store works — swap InMemoryCollection for Azure AI Search, Qdrant, Pinecone, etc. with no code changes to the model or agent logic.

The main difference with GoodMem seems to be that it's a hosted service that manages the embedding pipeline server-side. That's a valid product, but it doesn't address a gap in SK's abstractions — it's an alternative deployment model. Users who want a managed embedding service can already use Azure OpenAI embeddings or any other hosted embedding provider with our existing connectors.

We're going to close this for now, but if there's a specific capability gap you've identified that our current abstractions don't cover, we'd love to hear about it.

[MuaazWahid]

thanks for the thorough response @moonbox3. the "without GoodMem" example wasn't a fair comparison to Semantic Kernel's memory connectors. i'll update the codebase to reflect that.

SK's embedding generation, plugin exposure, and vector store support are solid. but i'd like to gently push back on framing GoodMem as a hosted service managing embedding pipeline server side. it's a different category of integration than the current memory store connectors.

your provided example still requires OpenAITextEmbedding() and dimensions=1536 specified in the data model. from what i can see, SK memory store connectors are thin vector db wrappers (ex: Pinecone, Qdrant, etc.). in order to setup a pipeline in the code, the developer has to: choose embedding provider, configure dimensions, chunk documents before upsert, implement reranking, and/or build agent isolation logic. SK has great tools to make this easy, but the dev has to set this up for every app.

GoodMem places this entire pipeline into infrastructure rather than application code. a self hosted GoodMem instance handles:

• chunking at ingest: SK has TextChunker decoupled from VectorStoreCollection. chunking is handled manually before calling upsert(). GoodMem accepts full text input, handles chunking server side, devs can choose the chunking strategy, and returns chunks on search. this is an architectural difference with VectorStoreCollection[TKey, TModel] where upsert and search operate on different shapes (we worked around this).
• embedding as an infrastructure configuration: no embedder or dimensions attached to data model, no api key in code. change embedder on GoodMem server, every agent will inherit it (weaviate does this too via vectorizer modules, but using GoodMem comes with added benefits)
• self-hosting/data sovereignty: GoodMem is PostgreSQL backed and can be self hosted. this can appeal to developers/enterprise teams that can't send data to managed vector db services.
• multi-agent memory isolation: GoodMem isolates agent memory corpora into "Spaces", no app level logic required from devs.
• cross-framework sharing: SK (Python), SK (Java/.NET), LangChain, and Google ADK agents read/write the same "Spaces" simultaneously. current SK connectors and backing vector DBs aren't designed for this.

i understand this may be different than Semantic Kernel's memory store connector model and i believe this is GoodMem's value to SK. GoodMem is an easy plug and play memory backend with near zero configuration and maintenance.

happy to reframe this as a connector contribution rather than a feature request if you would like.