Embedding Providers, Ollama, Memory Graph & Working Memory

#[0.15.0] - 2026-04-08

Major release introducing a pluggable embedding provider system, local LLM support via Ollama, and significant memory plugin enhancements including a knowledge graph layer, working memory, reinforcement learning, and content preprocessing.

#Added

• Embedding Provider System (daita/embeddings/)

  New module mirroring the daita.llm pattern: BaseEmbeddingProvider abstract class, factory with registry, and five built-in providers. All providers include LRU caching and automatic tracing.

  • OpenAI — text-embedding-3-small / text-embedding-3-large
  • Voyage AI — voyage-3 and variants
  • Gemini — Google embedding models
  • Sentence Transformers — local HuggingFace models (no API key required)
  • Mock — deterministic vectors for testing

  python

  from daita.embeddings import create_embedding_provider
   
  embedder = create_embedding_provider("openai", model="text-embedding-3-small")
  vectors = await embedder.embed_texts(["hello", "world"])

  Register custom providers with register_embedding_provider(). BaseEmbeddingProvider is now exported from the top-level daita package.

  New pyproject.toml extras: voyage, sentence-transformers.

• Ollama LLM Provider (daita/llm/ollama.py)

  Run agents against local models via Ollama's OpenAI-compatible API. Supports any model available through ollama pull — llama3.1, mistral, gemma2, codestral, phi3, etc.

  python

  agent = Agent(
      name="local",
      llm_provider="ollama",
      llm_model="llama3.1",
  )

  Configurable via OLLAMA_BASE_URL environment variable (default: http://localhost:11434/v1). Connection errors produce clear diagnostics, including a specific message when running in Daita Cloud where Ollama is unsupported.

• Memory Graph (daita/plugins/memory/memory_graph.py)

  Lightweight knowledge graph layer over agent memories. Creates entity nodes from stored memories and connects them via relationships, enabling traversal queries like "what are all the infrastructure constraints for Project Orion?" that pure cosine similarity would miss.

  • Extracts entities from LLM-produced facts (via FactExtractor) or zero-LLM keyword heuristics (backtick code, capitalized phrases, table.column notation, quoted strings)
  • Entity quality filters exclude temporal phrases, currency amounts, bare numbers, and generic nouns
  • BFS traversal with configurable depth for relationship discovery
  • Uses the existing GraphBackend infrastructure with graph_type='memory'

  Enable with enable_memory_graph=True on MemoryPlugin. Adds the traverse_memory and query_facts tools.

• Working Memory (daita/plugins/memory/working_memory.py)

  Session-scoped scratchpad — in-memory only, no disk, no embeddings, no API calls. Auto-evicted on agent stop unless explicitly promoted to long-term memory via remember(promote_key=...).

  python

  memory = MemoryPlugin(enable_working_memory=True)
  # Agent can call scratch("raw notes here", key="analysis")
  # and think("what patterns did I see?") to search the scratchpad

  Enable with enable_working_memory=True. Adds scratch and think tools.

• Memory Reinforcement Learning

  Outcome-based feedback loop for memories. Agents can mark recalled memories as positive or negative, adjusting their effective scores in future recall. Enable with enable_reinforcement=True. Adds the reinforce tool.

• Memory Content Preprocessor (daita/plugins/memory/preprocessor.py)

  Splits raw content into two representations at ingestion: the original text for storage and a cleaned version for embedding/dedup/fact extraction. Strips code blocks, inline code, markdown formatting, and bullet prefixes so the embedding captures factual signal rather than formatting noise. Prevents structurally identical but factually different memories (e.g. two table schemas) from appearing as near-duplicates.

• Memory Tool Tiers

  MemoryPlugin now accepts a tier parameter ("basic", "analysis", "full") controlling which tools are exposed to the agent. The memory_tools parameter allows explicit tool selection for fine-grained control.

• EmbeddingProvider Interface (daita/core/interfaces.py)

  New EmbeddingProvider abstract base class defining the contract: dimensions property, embed_text(), and embed_texts().

• Memory Plugin — Custom Embedder Injection

  MemoryPlugin now accepts an embedder parameter — a pre-constructed BaseEmbeddingProvider instance that takes precedence over the embedding_provider/embedding_model string parameters.

#Changed

• Memory plugin tools extracted to standalone module (daita/plugins/memory/memory_tools.py)

  All tool handler functions moved out of MemoryPlugin into standalone functions that receive the plugin instance as their first argument, making them independently testable.

• Memory plugin search scoring improved (daita/plugins/memory/search.py)

  Search module updated with revised scoring logic to integrate reinforcement signals and memory graph context.

• Graph backend — new node/edge types

  Added MEMORY and ENTITY node types and MENTIONS edge type to daita/core/graph/models.py for the memory graph.

• Local graph backend expanded (daita/core/graph/local_backend.py)

  Added get_edges_from(), get_edges_to(), and get_all_nodes() methods required by memory graph traversal.

#Fixed

• Memory dedup threshold now configurable

  MemoryPlugin accepts dedup_threshold (default 0.95) instead of using a hardcoded value, allowing tuning for domains where default similarity thresholds are too aggressive.