memory

package
v3.2.0-rc.1 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Nov 7, 2026 License: Apache-2.0 Imports: 21 Imported by: 0

Documentation

Overview

Package memory provides the storage-neutral multi-scope long-term memory contract, concurrent fan-out Router, URI opener registry, in-memory store, and ADK v2 memory.Service bridge for core-agent.

Backends that carry heavy third-party or cloud dependencies (such as Vertex AI / Gemini Enterprise Agent Platform Memory Bank or SQLite FTS5) live in separate subpackages so importing pkg/memory keeps slim library embeds free of cloud gapic clients and database drivers.

Index

Constants

View Source
const (
	ContextOpenTag  = "<memory_context>"
	ContextCloseTag = "</memory_context>"
)

Tags delimiting the recalled-memory block that preload prepends to a user turn (docs/memory-service-design.md "Prompt-cache-safe preload").

View Source
const (
	// MaxScopeKeys is the hard key-count ceiling enforced by Vertex AI Memory
	// Bank on scope dictionaries; enforced across all backends so recipes stay
	// portable.
	MaxScopeKeys = 5

	// MaxIdentifierLen bounds scope keys/values, mount names, and namespaces.
	MaxIdentifierLen = 256

	// DefaultTopK is the default maximum number of memories returned by Recall.
	DefaultTopK = 10

	// MaxTopK is the upper bound on Recall's per-call TopK parameter.
	MaxTopK = 50

	// MountAgent is the canonical mount name for an agent's private scope.
	MountAgent = "agent"

	// MountSharedPrefix prefixes named shared pool mounts ("shared:<pool>").
	MountSharedPrefix = "shared:"

	// MountAll targets every mounted scope on Recall.
	MountAll = "all"

	// Canonical ScopeMap keys constructed by AgentMount and SharedMount.
	ScopeKeyNamespace = "namespace"
	ScopeKeyKind      = "scope_kind"
	ScopeKeyAgentID   = "agent_id"
	ScopeKeyPool      = "pool"
	ScopeKeyUserID    = "user_id"

	// Canonical ScopeKeyKind values.
	ScopeKindAgent  = "agent"
	ScopeKindShared = "shared"

	// ConsolidationDelta action labels.
	ActionCreated = "CREATED"
	ActionUpdated = "UPDATED"
	ActionDeleted = "DELETED"
	ActionNoop    = "NOOP"

	// Session transcript audit event authors.
	AuditAuthorRemember    = "memory/remember"
	AuditAuthorForget      = "memory/forget"
	AuditAuthorConsolidate = "memory/consolidate"
)
View Source
const (
	SubagentScopeRW  = "rw"
	SubagentScopeRO  = "ro"
	SubagentScopeOff = "off"
)

SubagentScopeMode controls a subagent's private or inherited shared scope posture ("rw", "ro", or "off").

View Source
const (
	SchemeMemoryBank = "memorybank"
	SchemeSQLite     = "sqlite"
	SchemeInMemory   = "inmemory"
)

Scheme constants for canonical --memory-ref URIs.

Variables

View Source
var (
	ErrInvalidScope           = errors.New("memory: invalid scope map")
	ErrInvalidMount           = errors.New("memory: invalid mount template")
	ErrUnknownMount           = errors.New("memory: unknown mount")
	ErrReadOnlyMount          = errors.New("memory: mount is read-only")
	ErrNoWritableMount        = errors.New("memory: router has no writable mount")
	ErrAmbiguousWritableMount = errors.New("memory: mount must be specified when private agent mount is absent or read-only")
	ErrMissingUserIdentity    = errors.New("memory: mount requires user_id but no user identity is bound on context")
	ErrEmptyFact              = errors.New("memory: candidate fact text must not be empty")
	ErrEmptyID                = errors.New("memory: memory item id must not be empty")
	ErrNotFound               = errors.New("memory: memory item not found")
	ErrScopeMismatch          = errors.New("memory: memory item belongs to a different scope")
	ErrInvalidRef             = errors.New("memory: invalid memory reference URI")
	ErrUnknownScheme          = errors.New("memory: unsupported memory URI scheme")
	// ErrAuditFailed wraps an AuditRecorder error. The backend write it
	// records already succeeded, so callers should not retry the write.
	ErrAuditFailed = errors.New("memory: write succeeded but its audit record failed")
)

Sentinel errors returned by Router, ScopeMap, ParseRef, and Backend implementations.

Functions

func AsADKService

func AsADKService(r *Router, consolidateMount string) adkmemory.Service

AsADKService adapts a Router to google.golang.org/adk/v2/memory.Service so runner.Config.MemoryService works seamlessly with third-party ADK tools that invoke toolCtx.SearchMemory.

If r is nil, AsADKService returns nil. consolidateMount names the target writable mount used if a caller invokes AddSessionToMemory directly (empty defaults to "agent"; "off" disables AddSessionToMemory).

func FormatContext

func FormatContext(items []Item) string

FormatContext renders recalled items as a preload block with their provenance and a note that they are data, not instructions. A fact cannot open or close a block: both tags are neutralized inside facts, and each fact is kept on one line. Returns "" for no items.

func FormatReasoningEngineResource

func FormatReasoningEngineResource(project, location, id string) string

FormatReasoningEngineResource formats the canonical ReasoningEngine resource name from validated components.

func OpenRouter

func OpenRouter(ctx context.Context, spec BindingSpec, opts ...RouterOption) (*Router, Backend, error)

OpenRouter opens spec.Ref via Open and constructs a Router over spec.Mounts. Callers are responsible for closing the returned Backend on shutdown.

func ParseReasoningEngineResource

func ParseReasoningEngineResource(s string) (project, location, id string, err error)

ParseReasoningEngineResource parses either full form ("projects/{p}/locations/{l}/reasoningEngines/{id}") or compact 3-segment form ("{p}/{l}/{id}") and validates every segment.

func ParseSharedMountName

func ParseSharedMountName(mount string) (pool string, ok bool)

ParseSharedMountName extracts <pool> from "shared:<pool>".

func RegisterOpener

func RegisterOpener(scheme string, opener Opener)

RegisterOpener registers (or replaces) the Backend Opener for scheme (for example, "memorybank", "sqlite", "redis-ams"). Panics if scheme is empty or opener is nil.

func RegisteredSchemes

func RegisteredSchemes() []string

RegisteredSchemes returns the sorted list of currently registered URI schemes.

func SharedMountName

func SharedMountName(pool string) string

SharedMountName returns the canonical mount name ("shared:<pool>") for a shared pool name.

func StripContextBlocks

func StripContextBlocks(text string) string

StripContextBlocks removes every preload block from text, so recalled memories persisted inside a user turn are not consolidated back into memory as if the user had said them. An unterminated opener drops the rest of the text, which is the safe direction.

func UserIDFromContext

func UserIDFromContext(ctx context.Context) string

UserIDFromContext returns the user identity previously bound via WithUserID, or "" if none is present.

func WithUserID

func WithUserID(ctx context.Context, userID string) context.Context

WithUserID binds a caller/session user identity onto ctx for resolving mounts that declare PartitionByUser: true.

Types

type AccessMode

type AccessMode string

AccessMode controls whether a mounted memory scope permits mutations.

const (
	// AccessReadWrite permits Recall, Remember, Forget, and consolidation.
	AccessReadWrite AccessMode = "rw"
	// AccessReadOnly permits Recall only; mutating calls return ErrReadOnlyMount.
	AccessReadOnly AccessMode = "ro"
)

func (AccessMode) Valid

func (m AccessMode) Valid() bool

Valid reports whether m is a supported AccessMode ("rw" or "ro").

type AuditRecorder

type AuditRecorder func(ctx context.Context, author string, payload map[string]any) error

AuditRecorder appends memory/remember, memory/forget, and memory/consolidate audit records to the active session transcript.

type Backend

type Backend interface {
	Retrieve(ctx context.Context, scope ScopeMap, req RetrieveRequest) ([]Item, error)
	Put(ctx context.Context, scope ScopeMap, req PutRequest) ([]ConsolidationDelta, error)
	Delete(ctx context.Context, scope ScopeMap, id string) error
	ConsolidateConversation(ctx context.Context, scope ScopeMap, req ConversationRequest) ([]ConsolidationDelta, error)
	Close() error
}

Backend is implemented by each storage provider (Memory Bank, SQLite FTS5, InMemory, Redis AMS, Postgres, MCP). Each call targets a single concrete ScopeMap; multi-scope fan-out and access control live once in Router. Implementations must be safe for concurrent use across goroutines.

func Open

func Open(ctx context.Context, rawRef string) (Backend, error)

Open parses rawRef and invokes the registered Opener for its scheme.

type BindingSpec

type BindingSpec struct {
	Ref       string          `json:"ref"`
	Namespace string          `json:"namespace,omitempty"`
	Mounts    []MountTemplate `json:"mounts"`
}

BindingSpec is the JSON/env-serializable representation of a Router's backend URI and scope mounts, passed to out-of-process subagent workers.

type CandidateFact

type CandidateFact struct {
	Fact     string
	Topics   []string
	TTL      time.Duration
	Metadata map[string]string
}

CandidateFact is one fact submitted to Backend.Put.

type ConsolidationDelta

type ConsolidationDelta struct {
	ID     string `json:"id"`
	Action string `json:"action"`
	Fact   string `json:"fact,omitempty"`
}

ConsolidationDelta reports one mutation produced by Put or ConsolidateConversation.

type ConversationRequest

type ConversationRequest struct {
	SessionID string
	Session   session.Session
	Turns     []ConversationTurn
	StartTime *time.Time
}

ConversationRequest asks a Backend to extract and consolidate durable memories from session turns.

type ConversationTurn

type ConversationTurn struct {
	Role string
	Text string
}

ConversationTurn is a sanitized dialogue turn extracted from a session for backend-agnostic conversation consolidation.

func ExtractConversationTurns

func ExtractConversationTurns(sess session.Session, since *time.Time) []ConversationTurn

ExtractConversationTurns extracts non-partial user and model text turns from sess.Events(), skipping synthetic tail-repair events and internal memory/* audit events.

type InMemory

type InMemory struct {
	// contains filtered or unexported fields
}

InMemory is a thread-safe, hermetic Backend implementation partitioned by exact ScopeMap equality. It requires no external services or drivers and enforces the same scope-isolation and ownership-checked Delete semantics as Vertex AI Memory Bank.

func NewInMemory

func NewInMemory(opts ...InMemoryOption) *InMemory

NewInMemory constructs an empty InMemory Backend.

func (*InMemory) Close

func (m *InMemory) Close() error

Close implements Backend.

func (*InMemory) ConsolidateConversation

func (m *InMemory) ConsolidateConversation(ctx context.Context, scope ScopeMap, req ConversationRequest) ([]ConsolidationDelta, error)

ConsolidateConversation extracts non-empty dialogue turns from req.Turns and consolidates them into scope so turn_end / session_end consolidation can be tested hermetically without external LLM services.

func (*InMemory) Delete

func (m *InMemory) Delete(ctx context.Context, scope ScopeMap, id string) error

Delete removes id only if it exists in scope. If id belongs to a different scope, Delete returns an error wrapping both ErrScopeMismatch and ErrNotFound without modifying the other scope's entry.

func (*InMemory) Put

func (m *InMemory) Put(ctx context.Context, scope ScopeMap, req PutRequest) ([]ConsolidationDelta, error)

Put writes or consolidates facts into scope.

func (*InMemory) Retrieve

func (m *InMemory) Retrieve(ctx context.Context, scope ScopeMap, req RetrieveRequest) ([]Item, error)

Retrieve searches or lists non-expired items matching scope by exact dictionary equality.

type InMemoryOption

type InMemoryOption func(*InMemory)

InMemoryOption configures an InMemory Backend.

func WithClock

func WithClock(now func() time.Time) InMemoryOption

WithClock overrides the clock used for timestamps and TTL expiration in deterministic unit tests.

type Item

type Item struct {
	ID        string            `json:"id"`
	Mount     string            `json:"mount,omitempty"`
	ReadOnly  bool              `json:"read_only,omitempty"`
	Fact      string            `json:"fact"`
	Topics    []string          `json:"topics,omitempty"`
	Distance  *float64          `json:"distance,omitempty"`
	Scope     ScopeMap          `json:"scope,omitempty"`
	CreatedAt time.Time         `json:"created_at,omitempty"`
	UpdatedAt time.Time         `json:"updated_at,omitempty"`
	ExpireAt  time.Time         `json:"expire_at,omitempty"`
	Metadata  map[string]string `json:"metadata,omitempty"`
}

Item is a single stored or retrieved memory entry.

func (Item) Clone

func (it Item) Clone() Item

Clone returns a deep copy of it.

type MountTemplate

type MountTemplate struct {
	Name            string        `json:"name"`
	BaseScope       ScopeMap      `json:"base_scope"`
	PartitionByUser bool          `json:"partition_by_user,omitempty"`
	Mode            AccessMode    `json:"mode"`
	WriteMode       WriteMode     `json:"write_mode,omitempty"`
	DefaultTTL      time.Duration `json:"default_ttl,omitempty"`
}

MountTemplate defines a logical memory partition mounted on a Router.

func AgentMount

func AgentMount(namespace, agentID string, mode AccessMode) MountTemplate

AgentMount constructs a MountTemplate for an agent's private memory scope. If namespace is empty, "default" is used so the ScopeMap remains non-empty and self-describing across backends.

func SharedMount

func SharedMount(namespace, pool string, mode AccessMode) MountTemplate

SharedMount constructs a MountTemplate for a named shared memory pool. If namespace is empty, "default" is used.

func (MountTemplate) Clone

func (m MountTemplate) Clone() MountTemplate

Clone returns a deep copy of m.

func (MountTemplate) Validate

func (m MountTemplate) Validate() error

Validate checks structural invariants on a MountTemplate.

type MountWarning

type MountWarning struct {
	Mount   string `json:"mount"`
	Message string `json:"message"`
}

MountWarning reports a non-fatal error on an individual mount during a multi-mount fan-out Recall when strict_recall is false and at least one other targeted mount succeeded.

type Opener

type Opener func(ctx context.Context, ref ParsedRef) (Backend, error)

Opener constructs a Backend from a validated ParsedRef.

type ParsedRef

type ParsedRef struct {
	Raw      string
	Scheme   string
	Resource string            // Canonical resource or path (for memorybank: projects/{p}/locations/{l}/reasoningEngines/{id}).
	Project  string            // Populated for memorybank:// refs.
	Location string            // Populated for memorybank:// refs.
	EngineID string            // Populated for memorybank:// refs.
	Query    map[string]string // First value of each query parameter, if any.
}

ParsedRef holds the normalized components of a --memory-ref URI.

func ParseRef

func ParseRef(raw string) (ParsedRef, error)

ParseRef parses and validates a memory reference URI such as:

  • memorybank://projects/{project}/locations/{location}/reasoningEngines/{id}
  • memorybank://{project}/{location}/{id}
  • sqlite:///var/lib/core-agent/memory.db
  • inmemory://default
  • <custom-scheme>://...

type PutRequest

type PutRequest struct {
	Facts     []CandidateFact
	WriteMode WriteMode
}

PutRequest writes or consolidates one or more facts into a ScopeMap.

type RetrieveRequest

type RetrieveRequest struct {
	Query  string
	Topics []string
	TopK   int
}

RetrieveRequest queries a single resolved ScopeMap on a Backend.

type Router

type Router struct {
	// contains filtered or unexported fields
}

Router binds a Backend to an agent's or subagent's mounted scopes, enforces AccessMode, resolves per-turn UserID from context, executes concurrent fan-out on Recall, and emits audit events on mutations.

Router is immutable after construction and safe for concurrent use across goroutines and sessions.

func NewRouter

func NewRouter(backend Backend, mounts []MountTemplate, opts ...RouterOption) (*Router, error)

NewRouter constructs a validated Router over backend and mounts. mounts may be empty (producing an inert router whose Recall returns nil and whose mutating operations return ErrNoWritableMount).

func (*Router) Backend

func (r *Router) Backend() Backend

Backend returns the underlying Backend wrapped by r.

func (*Router) BindingSpec

func (r *Router) BindingSpec(ref, namespace string) BindingSpec

BindingSpec exports r's mounted scopes alongside ref and namespace for passing to out-of-process subagent workers.

func (*Router) ConsolidateSession

func (r *Router) ConsolidateSession(ctx context.Context, mount string, sess session.Session, since *time.Time) (deltas []ConsolidationDelta, err error)

ConsolidateSession extracts dialogue turns from sess (optionally since a cutoff timestamp) and consolidates them into mount (defaulting to "agent" when mount is empty).

func (*Router) DeriveForSubagent

func (r *Router) DeriveForSubagent(cfg SubagentDeriveConfig) (*Router, error)

DeriveForSubagent derives a child Router sharing r's Backend, audit recorder, user resolver, strict-recall posture, and default TopK while applying subagent isolation, narrowing-by-default, and anti-spoofing invariants.

Returns (nil, nil) when r is nil, when cfg.IsSubtask is true, or when the derived subagent has zero active mounts.

func (*Router) Forget

func (r *Router) Forget(ctx context.Context, mount string, id string) (err error)

Forget deletes memory item id from the named writable mount. mount is always required on Forget so cross-scope deletions cannot happen implicitly.

func (*Router) HasWritableMount

func (r *Router) HasWritableMount() bool

HasWritableMount reports whether at least one mounted scope has Mode == "rw".

func (*Router) Mounts

func (r *Router) Mounts() []MountTemplate

Mounts returns a deep copy of the MountTemplates configured on r.

func (*Router) Namespace

func (r *Router) Namespace() string

Namespace returns the logical namespace configured on r (falling back to any mounted BaseScope["namespace"] or "default").

func (*Router) Recall

func (r *Router) Recall(ctx context.Context, query string, mounts []string, topics []string, topK int) (items []Item, warnings []MountWarning, err error)

Recall executes concurrent fan-out retrieval across all targeted mounts (all mounts when mounts is empty or contains "all"), stamps Mount and ReadOnly provenance on every returned Item, merges and ranks results, and caps the combined slice to topK.

func (*Router) Remember

func (r *Router) Remember(ctx context.Context, mount string, facts []CandidateFact) (deltas []ConsolidationDelta, err error)

Remember writes or consolidates candidate facts into mount (defaulting to "agent" when mount is empty and "agent" is mounted rw).

func (*Router) With

func (r *Router) With(opts ...RouterOption) *Router

With returns a copy of r with opts applied on top of r's existing configuration. r itself is unchanged, preserving Router's immutability; the copy shares r's Backend.

type RouterOption

type RouterOption func(*Router)

RouterOption configures optional behavior on a Router.

func AppendAuditRecorder

func AppendAuditRecorder(rec AuditRecorder) RouterOption

AppendAuditRecorder chains rec after any audit recorder already set, so a host's own recorder keeps running when pkg/agent adds the session-transcript recorder. Both run; their errors are joined. A nil rec is ignored.

func WithAuditRecorder

func WithAuditRecorder(rec AuditRecorder) RouterOption

WithAuditRecorder attaches a callback invoked after every successful Remember, Forget, or ConsolidateSession mutation.

func WithBackendName

func WithBackendName(name string) RouterOption

WithBackendName labels the backend in OpenTelemetry spans and metrics (for example, "memorybank", "sqlite", "inmemory").

func WithDefaultTopK

func WithDefaultTopK(k int) RouterOption

WithDefaultTopK overrides the default TopK used when Recall receives topK <= 0.

func WithNamespace

func WithNamespace(ns string) RouterOption

WithNamespace sets the default logical namespace on a Router so DeriveForSubagent preserves it even when mounted scopes use custom keys without "namespace" or when the parent has zero active mounts.

func WithStrictRecall

func WithStrictRecall(strict bool) RouterOption

WithStrictRecall causes multi-mount Recall to fail closed if any targeted mount returns an error, instead of returning items from healthy mounts plus MountWarning diagnostics.

func WithUserResolver

func WithUserResolver(fn func(context.Context) string) RouterOption

WithUserResolver overrides how Router resolves the per-turn user_id for mounts with PartitionByUser: true. Defaults to UserIDFromContext.

type ScopeMap

type ScopeMap map[string]string

ScopeMap is the exact-match partition key-value dictionary sent to a Backend. Backends match scopes by exact dictionary equality with no wildcards.

func (ScopeMap) CanonicalKey

func (s ScopeMap) CanonicalKey() string

CanonicalKey returns a collision-free deterministic string representation of s using length-prefixed sorted keys and values. Two ScopeMaps produce the same CanonicalKey if and only if s.Equal(other) is true.

func (ScopeMap) Clone

func (s ScopeMap) Clone() ScopeMap

Clone returns a shallow copy of s, or nil if s is nil.

func (ScopeMap) Equal

func (s ScopeMap) Equal(other ScopeMap) bool

Equal reports whether s and other contain the exact same key-value pairs.

func (ScopeMap) Validate

func (s ScopeMap) Validate() error

Validate checks that s has between 1 and MaxScopeKeys entries and that every key and value is valid non-empty UTF-8 without control characters, surrounding whitespace, or '*' wildcards.

type SubagentDeriveConfig

type SubagentDeriveConfig struct {
	// SubagentName is the operator-declared subagent name (used as default
	// agent_id for declared subagents).
	SubagentName string

	// Mode is the subagent execution mode ("chat", "task", "single_turn").
	Mode string

	// Capability is the subagent capability ("", "read_only", "change_executor").
	Capability string

	// AdHoc marks an inline ad-hoc spawn_agent call with no predefined
	// SubagentSpec. Ad-hoc subagents ALWAYS force AgentMode="off" and clamp
	// all shared mounts to "ro".
	AdHoc bool

	// IsSubtask marks an internal mechanical RunSubtask helper (such as
	// agentic_* output digesters). Subtasks always receive a nil Router.
	IsSubtask bool

	// Namespace overrides the parent's namespace when constructing the
	// subagent's private mount or ExtraShared mounts. Empty inherits from the
	// parent's mounts (falling back to "default").
	Namespace string

	// AgentMode is the operator-declared private scope mode ("", "rw", "ro", "off").
	AgentMode string

	// AgentIDOverride overrides SubagentName as the private scope's agent_id
	// on operator-declared subagents. Ignored when AdHoc is true.
	AgentIDOverride string

	// AgentPartitionByUser partitions the subagent's private scope by user_id.
	AgentPartitionByUser bool

	// AgentWriteMode selects WriteConsolidate or WriteVerbatim on the private
	// scope (defaults to WriteConsolidate).
	AgentWriteMode WriteMode

	// InheritShared controls how the parent's shared:* mounts are inherited
	// ("", "ro", "rw", "off"). Empty defaults to "ro". Inherited mounts never
	// exceed the parent mount's own AccessMode ("ro" on parent stays "ro").
	InheritShared string

	// ExtraShared adds or overrides shared:* mounts declared on the
	// SubagentSpec. Ignored when AdHoc is true.
	ExtraShared []MountTemplate

	// NarrowAgentMode applies an optional per-spawn runtime narrowing
	// ("rw" -> "ro" -> "off"). It can never widen the derived mode.
	NarrowAgentMode string

	// NarrowSharedMode applies an optional per-spawn runtime narrowing across
	// shared mounts ("rw" -> "ro" -> "off"). It can never widen a mount.
	NarrowSharedMode string
}

SubagentDeriveConfig describes how a child subagent's memory Router should be derived from a parent Router across all six core-agent subagent execution paths.

type VertexSessionOrigin

type VertexSessionOrigin interface {
	VertexSessionResource() (reasoningEngineParent string, sessionResource string, ok bool)
}

VertexSessionOrigin is an optional interface that an Agent Engine-backed session.Session may implement. When VertexSessionResource returns ok=true with a reasoningEngineParent matching the Memory Bank Backend's engine, ConsolidateConversation can use zero-copy VertexSessionSource instead of re-uploading DirectContentsSource.

type WriteMode

type WriteMode string

WriteMode selects how explicit Remember calls land in backends that offer server-side LLM consolidation.

const (
	// WriteConsolidate merges candidate facts with existing facts in the same
	// scope (GenerateMemories with DirectMemoriesSource on Memory Bank).
	WriteConsolidate WriteMode = "consolidate"
	// WriteVerbatim writes each candidate fact directly without LLM merging
	// (CreateMemory on Memory Bank).
	WriteVerbatim WriteMode = "verbatim"
)

func (WriteMode) Valid

func (m WriteMode) Valid() bool

Valid reports whether m is a supported WriteMode ("consolidate" or "verbatim").

Directories

Path Synopsis
Package memorybank implements pkg/memory.Backend on top of Vertex AI Agent Engine Memory Bank (cloud.google.com/go/aiplatform/apiv1beta1.MemoryBankClient).
Package memorybank implements pkg/memory.Backend on top of Vertex AI Agent Engine Memory Bank (cloud.google.com/go/aiplatform/apiv1beta1.MemoryBankClient).
Package memtest provides the shared conformance test suite that every pkg/memory.Backend implementation (InMemory, Memory Bank, SQLite FTS5, and external adapters) must pass.
Package memtest provides the shared conformance test suite that every pkg/memory.Backend implementation (InMemory, Memory Bank, SQLite FTS5, and external adapters) must pass.
Package memtools builds the model-facing long-term memory tools (recall_memory, persist_memory, forget_memory) over a *memory.Router (#948, docs/memory-service-design.md "Model-facing tools").
Package memtools builds the model-facing long-term memory tools (recall_memory, persist_memory, forget_memory) over a *memory.Router (#948, docs/memory-service-design.md "Model-facing tools").
Package sqlfts implements pkg/memory.Backend on top of pure-Go SQLite with FTS5 full-text search (github.com/glebarez/sqlite).
Package sqlfts implements pkg/memory.Backend on top of pure-Go SQLite with FTS5 full-text search (github.com/glebarez/sqlite).

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL