Building a copilot?

Your copilot knows the question.
Not the person asking it.

Without context, your copilot treats every user the same and every question the same. Docklee enriches each request with what the user is doing right now, what they've done before, and what your product knows. One integration. Your copilot stops being generic.

  • Session context: what the user is looking at right now, injected automatically
  • User memory: their history, patterns, and past queries, fetched per request
  • Your knowledge base: relevant docs and guides surfaced for each question
Why did my conversion rate drop?

No context

Docklee context

A copilot is only useful when it knows who it's talking to. Docklee is the context layer that makes your copilot feel like it actually knows your users.

Integration model

One call

lynk.recall() before your LLM

Context sources

3 live

Session, memory, knowledge base

Your copilot

Unchanged

Same LLM, same response format

The gap

Generic answers lose users. Specific answers keep them.

Without Docklee

Your copilot treats every user the same because it has no way to know their history or preferences

With Docklee

Docklee fetches the user's memory on every request so your copilot knows their patterns, past queries, and context

Without Docklee

Questions about what the user is currently looking at get generic answers because the copilot can't see the screen

With Docklee

Session context shows your copilot exactly what screen and data the user is viewing when they ask the question

Without Docklee

Every question is answered from model weights alone, with no access to your actual product knowledge

With Docklee

Knowledge base retrieval gives your copilot access to your docs, runbooks, and guides for every relevant question

How it works

Docklee enriches the request.
Your LLM does the rest.

Step 01

Request arrives at your copilot

Your copilot handler receives the user's message as normal. Nothing about your routing, auth, or session logic changes. Docklee is invoked as a single call before your LLM sees the request.

Step 02

Docklee enriches in parallel

Three sources are queried simultaneously: the current session state (what the user is looking at), user memory (their history and patterns), and your knowledge base (relevant documentation). The enriched bundle is returned in under 50ms.

Step 03

Your LLM answers with full context

You inject the enriched system prompt into your existing LLM call. The model now knows exactly who the user is, what they're currently doing, and what your product knows about the question. No new model. No new infrastructure.

Request enrichment
Live

Why did my conversion rate drop?

Raw request

{  "user_id":    "user_7x91k",  "message":   "Why did my conversion drop?",  "session_id": "sess_abc123"}

Integration

One enrichment call.
A completely different copilot.

The "Before" tab shows your current handler. The "After" tab shows the one change. Same LLM, same model, same response flow. Docklee only adds context.

  • npm install docklee, nothing else to set up
  • Works with Express, Next.js, FastAPI, raw HTTP
  • Pass the current screen for proactive context
  • Citations on every response for transparency
Your copilot with Docklee context
import { Lynk } from "docklee";
const lynk = new Lynk({ engineId: "eng_product", memorySpaceId: "space_app" });
// Same handler, context added before your LLM
app.post("/copilot/ask", async (req, res) => {
const { userId, message } = req.body;
// Pull this user's memory and your product knowledge
const [memories, docs] = await Promise.all([
lynk.recall(message, { endUser: userId, topK: 5 }),
lynk.retrieve(message, { topK: 5 }),
]);
// Your LLM now knows who the user is,
// what they've done, and what your docs say.
const reply = await openai.chat({
model: "gpt-4o",
messages: [
{ role: "system", content: buildContext(memories, docs) },
{ role: "user", content: message },
],
});
res.json({ message: reply.content, sources: docs.map((d) => d.section) });
});

What Docklee adds

Everything a context-aware copilot needs.

Session context

The user's current screen, active data, and recent interactions are available on every request. Your copilot knows what the user is looking at without any manual instrumentation.

User memory

Every user's history, past queries, and interaction patterns are fetched and injected automatically. Your copilot personalises every response without you managing any state.

Knowledge base access

Relevant documentation, guides, and runbooks are retrieved for each question. Your copilot answers from your actual product knowledge, not just what the model was trained on.

Sub-50ms enrichment

All three sources are queried in parallel. The enriched bundle is returned before your user notices any latency difference. Docklee does not add meaningful latency to your handler.

Per-user access scoping

Context is scoped to what the requesting user is authorised to see. Memory and knowledge are filtered by access policy before they reach the model. No data leaks between users.

No new infrastructure

You call Docklee's managed API. You do not host vector stores, manage embeddings, or build retrieval pipelines. Your existing LLM call stays exactly as it is.

Building a copilot?

Stop shipping copilots
that don't know your users.

One npm install. One enrichment call. Your copilot knows who it's talking to from the first message.