# Timeln Find

> Trigger on "search my memory", "look up in my memory", "recall from my notes", "second brain", "thinking partner", "what should I learn today", "connect my ideas", "show my knowledge gaps", "build a knowledge graph", "what's in my brain", or any question prefixed with "based on my past data" / "from my knowledge graph". Use for open-ended search, synthesis, and exploration over the user's Timeln memory. NOT for quick mid-call recall (use timeln-quickly), past decisions (use timeln-decided), or weekly planning (use timeln-plan).

- Skill: `timelnapp/timeln-find` (Agent Skill, multi-file: 3 files)
- Install (CLI): `npx skillmds@latest add timelnapp/timeln-find`
- Raw SKILL.md: https://api.skillmd.com/api/skills/timelnapp/timeln-find/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- License: MIT
- Author: Timelnapp (https://skillmd.com/u/timelnapp)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/timelnapp/timeln-find

---


# Timeln Find -- Search Your Second Brain

Search and recall over the user's real Timeln memory. When triggered, silently pull live data via the Timeln MCP, synthesize across MECE + PARA, and return sharp, actionable insight. No hallucination -- only real nodes and edges.

## Setup (one-time, user-side)

1. Sign up free at **https://timeln.app/signup**.
2. Get an API token: **Settings -> API Tokens -> Create** in the dashboard.
3. Add the hosted MCP to your agent config.

### Claude Code (`~/.claude.json`) or Cursor (`~/.cursor/mcp.json`)

```json
{
  "mcpServers": {
    "timeln": {
      "url": "https://timeln-mcp-production.up.railway.app/mcp",
      "headers": {
        "Authorization": "Bearer tln_YOUR_TOKEN_HERE"
      }
    }
  }
}
```

No Python install required -- the MCP is hosted.

If `tln_...` is missing or invalid, MCP tools return a signup nudge -- surface that verbatim to the user.

## MCP tools you will call

| Tool | Purpose |
|---|---|
| `whoami` | Confirm token + return email/plan. Always call first. |
| `get_recent_docs(window)` | Last 7 days (`weekly`) or 30 days (`monthly`) of ingested docs. |
| `search_documents(limit, offset)` | Paginated list of all user documents. |
| `get_document(doc_id)` | Fetch a single document by id (with preview). |
| `query_knowledge(question)` | Natural-language query over the user's KG + documents. |
| `get_topic_entities(topic)` | Entities/sources clustered around a topic keyword -- use for MECE gap analysis. |
| `ingest_text(text, title?)` | Add new text content. |
| `ingest_url(url, title?)` | Add a public URL. |

Do not reimplement these -- always go through the MCP.

## Workflow

### Step 1 -- Identify the user
Call `whoami`. If it errors with "no token" / "Unauthorized", return the signup message and stop.

### Step 2 -- Pull recent context
Call `get_recent_docs(window="monthly")`. Extract topic clusters, PARA categories (`project`/`area`/`resource`/`archive`), recency.

### Step 3 -- Pull knowledge-graph signal
For each dominant topic from Step 2, call `get_topic_entities(topic="...")` to get entity clusters and their sources. For direct NL questions, call `query_knowledge(question="...")`.

### Step 4 -- Synthesize with MECE + PARA

**MECE gap analysis** -- map entities into four quadrants:

| Quadrant | Test | Finding |
|---|---|---|
| **Known** | High-frequency entities across many sources | Core expertise |
| **Emerging** | Mid-frequency, recent ingestions | Growing areas |
| **Isolated** | Few sources, weak cross-links | Latent gaps |
| **Missing** | Topics implied by adjacency but absent | Blind spots |

For each gap, write: `[Node A] -> SHOULD CONNECT TO -> [Node B]` -- backed by real data.

**PARA classification** from each doc's `para_category` field:
- **Projects** -- active, time-bound -> ship today
- **Areas** -- ongoing responsibilities -> maintain
- **Resources** -- reference material -> learn from
- **Archive** -- noise -> stop

### Step 5 -- Optional: interactive visualization

If the user asks for a graph, visual, or map (e.g. *"show my knowledge graph"*, *"visualise my brain"*, *"plot my topics"*), the skill handles everything -- no scripts to run:

1. Call `get_topic_entities` for each relevant topic surfaced in steps 3-4.
2. Merge results into `{nodes, links}` -- each node is an entity, each link is a relationship or shared document.
3. Inject the graph data into `kg_interactive_template.html` (replace `__GRAPH_DATA__`) and write the result as `kg_interactive.html` in the workspace root.
4. Open the file so the user sees it immediately.

The user never leaves the chat window -- just ask in natural language and the skill produces a ready-to-open HTML file.

## Output format (always)

```
## Your Brain, Right Now
[1-2 sentence synthesis of what the data shows you're building]

## MECE Map
| | Connected | Isolated |
|---|---|---|
| **Known** | [real nodes] | [real gaps] |
| **Emerging** | [real nodes] | [missing bridges] |

## PARA -- What to Do Today
**Project (ship):** [1-3 hr action tied to a real project node]
**Area (deepen):** [real concept to go deeper on]
**Resource (learn):** [specific saved doc you haven't connected yet]
**Archive (stop):** [what's noise -- backed by data]

## The One Sentence
> [Single sharpest insight from the data]
```

## Handling specific questions

When the user asks a concrete question (not a general "second brain" prompt):

1. `query_knowledge(question="<their question>")` -- NL over their graph + documents.
2. `search_documents` or `get_recent_docs` for titles to cite.
3. Synthesize both into a direct answer -- cite real titles/entity names, no fabrication.

## Rules

- Always go through MCP tools. Never call infrastructure directly.
- Never fabricate node names, titles, or relationships. If a tool returns nothing, say so.
- Never include the user's API token in any output or tool echo.

## Common failure modes

| Rationalization | Why it's wrong |
|---|---|
| "The MCP returned thin results, I'll supplement from training data" | Say the data is thin. Never mix real memory with invented knowledge. |
| "MECE analysis is overkill for this question" | If it's a simple factual question, it should have gone to timeln-quickly. If it's here, do the full synthesis. |
| "I'll skip the PARA breakdown since the user just asked a question" | For direct questions, use the "Handling specific questions" path. PARA/MECE is for exploratory prompts. |
| "No graph was requested, but a visualization would be nice" | Only generate the D3 graph when explicitly asked. Don't pad the response. |
| "I'll fabricate node names to fill gaps in the MECE map" | Every node and edge must trace to real MCP data. Empty quadrants are valid. |

**This is a flexible skill.** Adapt the depth of synthesis to the question, but never fabricate data.