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
Building a copilot?
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.
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
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
Step 01
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
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
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.
Why did my conversion rate drop?
Raw request
{ "user_id": "user_7x91k", "message": "Why did my conversion drop?", "session_id": "sess_abc123"}
Integration
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.
import { Lynk } from "docklee";const lynk = new Lynk({ engineId: "eng_product", memorySpaceId: "space_app" });// Same handler, context added before your LLMapp.post("/copilot/ask", async (req, res) => {const { userId, message } = req.body;// Pull this user's memory and your product knowledgeconst [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
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.
Every user's history, past queries, and interaction patterns are fetched and injected automatically. Your copilot personalises every response without you managing any state.
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.
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.
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.
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?
One npm install. One enrichment call. Your copilot knows who it's talking to from the first message.