# MemoryProxy Injection Pipeline: Understanding ContextContentProvider and InjectionHook Abstractions

> Explore the MemoryProxy injection pipeline and its key abstractions: InjectionHook for protocol-agnostic context injection and ContextContentProvider for creating cache-aware injectors. Learn how they work together.

- Repository: [Tencent Cloud/TencentDB-Agent-Memory](https://github.com/TencentCloud/TencentDB-Agent-Memory)
- Tags: internals
- Published: 2026-09-01

---

**The MemoryProxy injection pipeline in TencentDB-Agent-Memory uses the `InjectionHook` interface as its core abstraction, enabling protocol-agnostic context injection at specific `InjectionPoint` locations, while provider utilities in `ContextContentProvider` (via `createInjectionHook`) simplify the creation of cache-aware injectors that return `ContextBlock` arrays.**

The TencentDB-Agent-Memory repository implements a sophisticated **MemoryProxy injection pipeline** that enriches LLM requests before they reach the model. This system relies on a strictly typed hierarchy of abstractions—centered on the `InjectionHook` contract and supporting provider utilities—to inject contextual blocks at precise conversation boundaries. The architecture supports priority-ordered execution, semantic anchoring, and cache-aware prewarming across different agent protocols.

## The Core Data Model: ContextBlock and AgentContext

The pipeline operates on immutable data structures defined in [`MemoryProxy/src/injection/types.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/MemoryProxy/src/injection/types.ts). Understanding these foundation types is essential before implementing custom hooks.

### ContextBlock: The Atomic Content Unit

Every piece of injectable content is encapsulated as a `ContextBlock`. This union type supports text, tool calls, images, and custom payloads, making the pipeline protocol-agnostic.

```typescript
export type ContextBlockType =
  | "text" | "tool_use" | "tool_result" | "thinking" | "image" | "custom";

export interface ContextBlock {
  type: ContextBlockType;
  content: string;
  metadata?: Record<string, unknown>;
}

```

### AgentContext: The Pipeline Payload

The `AgentContext` interface (lines 128–146 in [`types.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/types.ts)) represents the complete request state traversing the pipeline. It aggregates messages, available tools, request parameters, and metadata.

```typescript
export interface AgentContext {
  messages: ContextMessage[];
  tools?: AgentTool[];
  requestParams: Record<string, unknown>;
  metadata: AgentContextMetadata;
}

```

The `AgentContextMetadata` sub-interface carries trace identifiers, user/session context, and protocol information required by injectors to make contextual decisions.

## Injection Points and Semantic Anchoring

The MemoryProxy injection pipeline supports nine distinct `InjectionPoint` values (lines 148–164), defining exactly where content modification occurs:

- **System message boundaries**: `system.prefix`, `system.suffix`, `system.before_tools`, `system.after_tools`
- **User message boundaries**: `user.before`, `user.after`, `user.first_turn`
- **Tool list modifications**: `tools.append`, `tools.prepend`

### Portable Anchoring with SemanticSlot

For agents requiring precise structural placement, the `AnchorTarget` interface combines with `SemanticSlot` types to declare *which* conceptual region (e.g., `"persona"`, `"memory"`, `"knowledge"`) receives the injection, independent of the underlying protocol representation.

```typescript
export type SemanticSlot = "persona" | "tools" | "skills" | "memory" | "knowledge" | "rules" | "task_context" | (string & {});

export interface AnchorTarget {
  slot?: SemanticSlot;
  rawKey?: string;
  relation: AnchorRelation;
}

```

## The InjectionHook Interface: Core Abstraction

The `InjectionHook` interface (lines 122–162 in [`types.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/types.ts)) is the primary contract that all context injectors must implement. This abstraction decouples content generation from application logic.

```typescript
export interface InjectionHook {
  id: string;
  point: InjectionPoint;
  anchor?: AnchorTarget;
  priority: HookPriority;
  description: string;
  cacheStrategy?: CacheStrategy;
  prewarm?(input: PrewarmInput): Promise<ContextBlock[]> | ContextBlock[];
  execute(ctx: AgentContext): Promise<ContextBlock[]> | ContextBlock[];
}

```

Key properties include:
- **point**: The specific `InjectionPoint` where execution triggers
- **priority**: Numeric execution order (lower values execute first)
- **cacheStrategy**: Controls precomputation via `"none"`, `"session_init"`, or `"hybrid"` modes
- **prewarm**: Optional initialization function receiving `PrewarmInput` (containing `keyId`, `userId`, `sessionInfo`)
- **execute**: The main method receiving `AgentContext` and returning `ContextBlock[]` arrays

## Hook Priority and Registration

### Execution Ordering with HookPriority

The pipeline respects explicit numerical priorities. The `HOOK_PRIORITY` constant (lines 332–353) provides sensible defaults:

```typescript
export const HOOK_PRIORITY = {
  SYSTEM: 0,
  MEMORY: 100,
  SKILL: 200,
  WIKI: 300,
  CUSTOM: 1000,
} as const;

```

### The HookRegistry Contract

The `HookRegistry` interface (lines 64–78) manages hook lifecycle and retrieval. Implementations guarantee that `getHooks(point)` returns injectors sorted by priority for deterministic execution order.

```typescript
export interface HookRegistry {
  register(hook: InjectionHook): void;
  unregister(hookId: string): void;
  getHooks(point: InjectionPoint): InjectionHook[];
  getAll(): InjectionHook[];
}

```

The concrete implementation resides in [`MemoryProxy/src/injection/registry.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/MemoryProxy/src/injection/registry.ts), while the factory function `createInjectionHook` in [`MemoryProxy/src/injection/provider.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/MemoryProxy/src/injection/provider.ts) simplifies instantiation of compliant objects.

## Cache-Aware Execution Strategies

The pipeline optimizes performance through the `CacheStrategy` union type (`"none" | "session_init" | "hybrid"`). When set to `"session_init"` or `"hybrid"`, the `prewarm` method executes once during session establishment, allowing expensive data fetching (e.g., loading conversation history from TencentDB) to occur before the first turn.

The `PrewarmInput` interface supplies session context including `keyId`, `agentSource`, `spaceId`, and `sessionInfo`, enabling injectors to preload user-specific data.

## Pipeline Orchestration

The `InjectionPipeline` implementation in [`MemoryProxy/src/injection/pipeline.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/MemoryProxy/src/injection/pipeline.ts) coordinates the complete flow:

1. **Warm-up Phase**: Invokes `prewarm` on hooks with applicable cache strategies
2. **Execution Phase**: Collects `ContextBlock` arrays from hooks at each `InjectionPoint` in priority order
3. **Application Phase**: Merges injected blocks into the `AgentContext` according to semantic or positional rules
4. **Observation Phase**: Optional `InjectionObserver` integrations (defined in [`observer.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/observer.ts)) emit telemetry to systems like Langfuse

## Practical Implementation Example

Implementing a custom injector requires implementing the `InjectionHook` contract and registering via the provider utilities:

```typescript
import { createInjectionHook } from "./injection/provider.js";
import { HOOK_PRIORITY, InjectionPoint } from "./injection/types.js";

const memoryInjector = createInjectionHook({
  id: "mem-recent-conversation",
  point: "user.before",
  priority: HOOK_PRIORITY.MEMORY,
  description: "Inject recent conversation snippets",
  cacheStrategy: "hybrid",
  async prewarm(input) {
    // Called once per session during initialization
    const recent = await fetchRecentMessages(input.keyId);
    return recent.map(txt => ({ type: "text", content: txt }));
  },
  async execute(ctx) {
    // Called per-turn for dynamic context
    return [{ type: "text", content: "Remember to check the latest logs." }];
  },
});

// Register with the global registry
registry.register(memoryInjector);

// Execute via the pipeline
const pipeline = getInjectionPipeline({});
const enrichedCtx = await pipeline.run(originalAgentContext);

```

This example demonstrates the **ContextContentProvider** pattern: the `createInjectionHook` factory transforms a configuration object into a fully compliant `InjectionHook`, handling interface conformance automatically.

## Summary

- The **MemoryProxy injection pipeline** centers on the `InjectionHook` interface defined in [`MemoryProxy/src/injection/types.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/MemoryProxy/src/injection/types.ts), which standardizes how contextual content enters the LLM request flow.
- **Nine distinct `InjectionPoint` values** allow precise placement of injected content at system, user, or tool boundaries.
- **Priority-based execution** (via `HookPriority` and `HOOK_PRIORITY` constants) ensures system-level hooks execute before skill or memory hooks.
- **Cache strategies** (`"session_init"`, `"hybrid"`) enable expensive data loading during session initialization via the `prewarm` lifecycle method.
- The **`createInjectionHook` factory** in [`MemoryProxy/src/injection/provider.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/MemoryProxy/src/injection/provider.ts) implements the ContextContentProvider pattern, simplifying the creation of type-safe injectors.
- The **Pipeline orchestrator** in [`MemoryProxy/src/injection/pipeline.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/MemoryProxy/src/injection/pipeline.ts) coordinates hook execution and block application across the conversation lifecycle.

## Frequently Asked Questions

### What is the difference between InjectionHook and ContextContentProvider?

**`InjectionHook`** is the strict TypeScript interface defining the contract for all injectors (id, point, priority, execute/prewarm methods), while **ContextContentProvider** refers to the factory utilities (particularly `createInjectionHook` in [`provider.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/provider.ts)) that instantiate these hooks. The provider abstracts boilerplate, allowing developers to supply only the configuration and logic functions while ensuring type safety.

### How does hook priority affect injection order?

The `priority` property (typed as `HookPriority`, which is a `number`) determines execution sequence within each `InjectionPoint`. Lower numeric values execute first. The system provides predefined constants in `HOOK_PRIORITY`: `SYSTEM` (0), `MEMORY` (100), `SKILL` (200), `WIKI` (300), and `CUSTOM` (1000). The `HookRegistry` implementation automatically sorts hooks by priority when retrieved for a specific point.

### What are the available cache strategies for injection hooks?

The `CacheStrategy` type supports three modes: `"none"` (execute `execute()` every turn), `"session_init"` (execute `prewarm()` once at session start and cache results), and `"hybrid"` (combine both—use `prewarm` for static data and `execute` for dynamic per-turn context). The `PrewarmInput` interface supplies session metadata including `keyId`, `userId`, and `agentSource` during the warm-up phase.

### Where are the concrete implementations of the injection pipeline located?

The core type definitions reside in [`MemoryProxy/src/injection/types.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/MemoryProxy/src/injection/types.ts). The pipeline orchestrator is implemented in [`MemoryProxy/src/injection/pipeline.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/MemoryProxy/src/injection/pipeline.ts), while hook registration logic lives in [`MemoryProxy/src/injection/registry.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/MemoryProxy/src/injection/registry.ts). Factory functions for creating hooks are found in [`MemoryProxy/src/injection/provider.ts`](https://github.com/TencentCloud/TencentDB-Agent-Memory/blob/main/MemoryProxy/src/injection/provider.ts), and real-world injector examples (such as tool injectors) are located in `MemoryProxy/src/injection/injectors/`.