entertainment

Show HN: A Local-First Agentic Knowledge Manager

Kept: A New Frontier in AI Conversation Management

In a world where AI chatbots are becoming ubiquitous, keeping track of the countless interactions you have with them is a growing headache. Kept offers a simple, yet powerful, solution that stores every conversation locally as Markdown files and gives you a dedicated desktop app to search, browse, connect, and reuse that data. This article dives deep into Kept’s features, use cases, architecture, and place in the evolving AI ecosystem, exploring how it could change the way individuals and organizations interact with AI.

1. Introduction

Artificial‑intelligence chat services—ChatGPT, Claude, Gemini, Grok, Kimi, and many more—have become essential productivity tools for coders, writers, designers, researchers, and everyday users. As these assistants grow more sophisticated, people are spending more hours and time crafting prompts, refining outputs, and revisiting earlier conversations to extract insights or build upon prior work.

Yet the convenience of AI often comes at the cost of continuity. Chat logs get buried in browser tabs, pinned notes, or disjointed documents, and the knowledge you accumulate in those chats is fragmented. A developer might forget the specific prompt that got a perfect solution, a researcher might lose the chain of reasoning that led to a breakthrough, or a student might have an entire set of study notes scattered across multiple platforms. Re‑discovering this information is not only time‑consuming but also risky, as data can get lost when devices fail or when platform policies change.

Kept was designed to solve this exact problem. By converting every AI interaction into a locally stored Markdown file—rich with metadata, tags, and contextual links—it creates an immutable, searchable archive. The companion desktop application then lets you traverse that archive, connect threads, and reuse content in new conversations, all while staying offline and under your control.

2. The Problem Space

2.1 Fragmented AI Data

Multiple Platforms: Users engage with a variety of AI services, each with its own interface, data retention policies, and export options.
Ephemeral Sessions: Some chat platforms (e.g., in‑browser ChatGPT) limit the conversation length or only keep recent history.
Inconsistent Export Formats: Even when export options exist, they may deliver data in CSV, JSON, or proprietary formats that require extra effort to re‑import.
Limited Search: Built‑in search features are often basic and can’t connect related conversations across different platforms or sessions.

2.2 Security & Privacy Concerns

Cloud‑Based Storage: Many users store chat logs on cloud services (e.g., Google Drive, Notion). These can be susceptible to breaches, data loss, or policy changes that restrict access.
Compliance Issues: Enterprises dealing with regulated data (e.g., GDPR, HIPAA) need strict controls on where and how data is stored.
Control Over Data: Users want to own their AI conversation histories, especially when they involve sensitive or proprietary information.

2.3 Knowledge Reuse & Re‑prompting

Re‑prompting Overhead: Re‑using previous prompts or outputs often requires manual copying, which is error‑prone.
Missing Context: Without a central archive, users cannot easily find the context behind a solution, hindering deeper understanding.
Collaborative Knowledge Building: Teams working on a project want to share AI-derived insights while preserving the lineage of ideas.

3. Kept Overview

Kept is a lightweight, cross‑platform desktop application (available for Windows, macOS, and Linux) that functions as a local AI conversation manager. Its core premise is simple: every interaction with an AI—no matter which platform—becomes a Markdown file stored locally, with a standardized metadata header. The app then indexes these files, allowing for powerful search, connection, and reuse capabilities.

3.1 Supported AI Models

ChatGPT (OpenAI)
Claude (Anthropic)
Gemini (Google)
Grok (Eluvio)
Kimi (Tianjin Kimi)
[Add new models as they become popular]

Kept’s modular architecture lets developers add support for additional models through a simple plugin system. The app’s built‑in connectors automatically detect the format of an exported chat and convert it into the standardized Markdown structure.

3.2 Core Workflow

Export or Capture:

Users export chat logs from their AI platform or let Kept capture the conversation in real‑time via a browser extension or API hook.

Conversion to Markdown:

Kept parses the chat history, generating a Markdown file (.md) for each conversation. The file includes:
- A YAML front‑matter block with metadata (timestamp, model, tags, participants).
- The raw chat transcript formatted with block quotes for user messages and bold headings for AI responses.
- Any embedded code blocks, images, or files referenced.

Indexing:

The app builds an inverted index of all files, enabling full‑text search across conversations, tags, or metadata.

Browsing & Connecting:

The UI displays conversation timelines, tag clouds, and a “Connections” panel that visualizes how topics interlink across chats.

Reuse & Re‑prompting:

Users can select a segment of text or an entire conversation and inject it into a new chat. Kept can automatically generate a prompt or a “seed” that preserves the context.

3.3 Why Markdown?

Human‑Readable: Markdown is plain text, easily viewable in any editor or IDE.
Portable: No vendor lock‑in; files can be moved, backed up, or versioned.
Extensible: Front‑matter metadata can be enriched without changing the underlying file.
Rich Rendering: Many editors (VS Code, Obsidian, JupyterLab) render Markdown with syntax highlighting, code blocks, and even diagram generation.

4. Feature Deep‑Dive

Below we unpack Kept’s key features, illustrating how they address the pain points identified earlier.

4.1 Universal Export & Capture

| Feature | Description | Benefit | |---------|-------------|---------| | Multi‑Platform Export | Import chats from ChatGPT, Claude, Gemini, Grok, Kimi via ZIP/JSON/CSV files. | Seamless onboarding regardless of preferred AI provider. | | Real‑Time Capture | Browser extension hooks into the chat DOM and streams new messages to Kept in real time. | Eliminates manual export; ensures every chat is archived instantly. | | API Integration | For developers, Kept offers an SDK to pull chats from OpenAI, Anthropic, or custom endpoints. | Automates archival in production pipelines or CI/CD workflows. |

4.2 Structured Markdown Output

YAML Front‑Matter:

  ---
  title: "Design Patterns for React Hooks"
  model: "ChatGPT-4.0"
  date: 2024‑05‑27T12:34:56Z
  tags: [React, JavaScript, Design Patterns, AI]
  participants:
    - user
    - AI
  ---

Provides a searchable metadata block.

Rich Formatting:
User messages prefixed with >, AI responses as blockquotes with bold headings. Code snippets fenced with language tags (```js).
Attachments:
Images or PDF links embedded as Markdown references.

4.3 Advanced Search & Tagging

Full‑Text Search: Search across all conversation transcripts and metadata.
Faceted Filters: Narrow results by model, date range, tags, or participants.
Smart Suggestions: As you type a query, Kept offers auto‑complete suggestions based on tags or frequently used prompts.

4.4 Connection & Visualization

Thread Linking: Users can manually link related conversations or let Kept auto‑detect similarity (via cosine similarity on embeddings).
Graph View: A dynamic graph displays nodes (conversations) and edges (connections). Hovering over a node reveals metadata and a snippet.
Breadcrumb Navigation: When viewing a conversation, a breadcrumb shows the chain of connected chats, allowing users to traverse back to the source of an insight.

4.5 Re‑prompting & Content Reuse

“Reuse Prompt” Button: Select a segment and instantly create a new chat with that content pre‑prefixed as context.
Template Creation: Define reusable prompt templates that auto‑insert relevant tags and metadata when generating new chats.
Export to Chat: Directly feed a Markdown file back into an AI platform via API, preserving the context.

Shared Libraries: Teams can share a folder of Markdown files via a shared network drive or git repository.
Permission Controls: For sensitive data, Kept can encrypt files with a passphrase or integrate with hardware security modules.
Versioning: Kept integrates with git, allowing users to commit changes to conversation archives, track edits, and revert to earlier states.

4.7 Offline & Local First

All data lives on the user’s machine. No cloud sync means:

Zero Downtime: Even if internet goes down, the archive remains accessible.
Compliance: Meets strict data residency and privacy laws.
Speed: Search and indexing happen locally, providing instant responses.

4.8 Extensibility & Plugins

Kept’s architecture supports:

Third‑Party Integrations: Connect with JIRA, Notion, Trello, or GitHub issues.
Custom Exporters: Convert Markdown archives into PDFs, HTML pages, or Markdown‑to‑Wiki formats.
Custom AI Connectors: Developers can add new AI models via a simple plugin API.

5. Use Cases

Kept’s versatility makes it suitable for many personas. Below we detail scenarios where Kept can transform workflows.

5.1 Individual Developers

Prompt Management: Store complex prompts that solve specific problems, quickly load them for future projects.
Learning New Libraries: Archive step‑by‑step guides from AI and use the graph view to see how various libraries interconnect.
Debugging: Re‑play a previous session that discovered a bug, and use the context to reproduce or fix the issue.

5.2 Academic Researchers

Literature Review: Store AI‑generated summaries and insights for each paper; connect them to form a knowledge graph.
Experiment Replication: Archive the chain of prompts used to generate data or models, ensuring reproducibility.
Collaborative Writing: Share Markdown files with co‑authors, annotate them directly in Kept, and keep track of edits.

5.3 Creative Writers

Plot Development: Keep a log of story outlines generated by AI; connect them to track character arcs.
Idea Repository: Store prompts that generate character descriptions or dialogue snippets; reuse them across stories.
Style Consistency: Analyze AI outputs across multiple drafts to refine tone and style guidelines.

5.4 Product Managers

Feature Ideation: Capture AI‑driven brainstorming sessions; link them to user stories and roadmaps.
Competitive Analysis: Archive AI‑generated competitor reports; connect insights with market trends.
Stakeholder Communication: Convert AI summaries into polished reports directly from Kept.

5.5 Enterprises

Compliance Records: Store all AI interactions that influence business decisions, preserving audit trails.
Knowledge Base: Build an internal knowledge base of AI-generated answers, linking them to policy documents.
Training & Onboarding: Use Kept archives as training material for new hires, ensuring consistency in AI usage.

6. Technical Architecture

Kept’s design emphasizes speed, reliability, and security. Its stack can be summarized as follows.

6.1 Core Engine

Language: Rust (for the core indexing and storage) ensures high performance and low memory footprint.
Front‑End: Electron‑based UI (React + TypeScript) provides cross‑platform compatibility.
Storage: SQLite database stores metadata and file pointers; actual Markdown files are stored on disk.

6.2 Indexing Pipeline

Ingestion: When a new Markdown file arrives, the engine reads the YAML front‑matter and content.
Tokenization: Text is split into tokens, with stop‑words removed for efficient indexing.
Embedding Generation: Optional step: generate vector embeddings using a lightweight sentence‑embedding model (e.g., Sentence‑Transformers). These embeddings are stored in a vector index (FAISS).
Inverted Index: Builds term → file mapping for fast search.
Graph Construction: For connected conversations, the graph edges are derived from manual links or auto‑suggested similarity thresholds.

6.3 Security Layer

Encryption: Local files can be encrypted with AES‑256 if the user opts in.
Key Management: Kept can integrate with OS keychains or external HSMs.
Isolation: No external API calls are made for indexing; all data remains on the machine unless exported.

6.4 Extensibility APIs

Plugin System: Python and Node.js plugins can hook into ingestion, export, and UI events.
RESTful API: A local HTTP server allows external scripts to query or add conversations programmatically.
CLI Tools: kept-cli provides command‑line utilities for bulk operations.

7. Privacy & Compliance

7.1 Local‑First Philosophy

Kept’s core promise is that data never leaves the user’s device unless explicitly exported. This mitigates risks associated with:

Cloud Breaches: No cloud storage means attackers cannot target the data.
Vendor Policy Changes: Users are not subject to changes in third‑party terms of service.
Data Sovereignty: Enterprises can keep data within geographic boundaries.

Data Residency: Users can choose where the local database resides, ensuring compliance with national data residency laws.
Access Controls: Integration with Windows Credential Manager or macOS Keychain enables password protection.
Audit Trail: All operations are logged; users can export logs to a secure audit repository.

7.3 Export & Deletion

Selective Export: Users can export only the conversations they need, in any format (Markdown, PDF, CSV).
Permanent Deletion: Deleting a conversation removes the Markdown file and all database entries; users can also wipe the entire local store.

8. Pricing & Licensing

Kept is available under a tiered subscription model:

| Plan | Price (USD/month) | Features | |------|-------------------|----------| | Free | $0 | Unlimited conversations, local storage, basic search. | | Pro | $9.99 | Advanced graph view, auto‑linking, encrypted storage, API access. | | Team | $29.99 | Shared libraries, role‑based permissions, audit logs, single‑sign‑on. | | Enterprise | Custom | Dedicated support, on‑premises deployment, compliance modules, custom integrations. |

All plans include a 30‑day free trial of the Pro tier. Open‑source licensing is available for community-driven builds, encouraging custom forks and plugin development.

9. Competitive Landscape

Kept sits among a growing set of AI conversation management tools. Here’s a quick comparison:

| Tool | Core Focus | Storage | Search | Collaboration | Pricing | |------|------------|---------|--------|---------------|---------| | Kept | Universal AI archive | Local Markdown | Full‑text + metadata | Shared libraries, permissions | $0–$30+ | | ChatHub | Chatbot aggregator | Cloud | Basic | Team chat | $10–$20 | | PromptHero | Prompt repository | Cloud | Tag‑based | Public community | Free | | GPT‑Saver | ChatGPT specific | Local JSON | Basic | None | $5 | | AI‑Vault | Enterprise AI audit | Cloud | Advanced | Enterprise SSO | Custom |

Kept’s unique selling points are:

Local, Immutable Storage: Unlike cloud‑centric solutions, Kept guarantees data privacy.
Multi‑Model Support: Handles many AI platforms out of the box.
Markdown Standardization: Makes files portable across editors and version control systems.
Connection & Graphing: Visual representation of conversational dependencies.

10. Future Outlook

10.1 AI‑Driven Summarization

Kept plans to integrate lightweight summarization models that can auto‑generate concise summaries for each conversation, stored as part of the metadata. This will help users quickly skim through thousands of logs.

10.2 AI‑Powered Search

Beyond keyword search, future releases will support semantic search, letting users query by intent or conceptual similarity. Embeddings stored during indexing will enable this.

10.3 Collaborative Editing

A real‑time collaborative mode is on the roadmap, allowing multiple users to annotate and edit conversation archives simultaneously, akin to Google Docs but offline.

10.4 Cross‑Device Sync

While Kept prioritizes local storage, optional encrypted sync via a secure cloud bucket or end‑to‑end encrypted peer‑to‑peer network will allow users to access their archive on multiple devices.

10.5 Community Plugins

Kept will open its plugin ecosystem to developers, encouraging plugins for new AI models, export formats, and integration with other knowledge‑base tools.

11. Critical Evaluation

| Aspect | Strength | Limitation | |--------|----------|------------| | Ease of Use | Simple drag‑and‑drop export; intuitive UI | Browser extension requires manual installation | | Data Control | Local, encrypted storage | No built‑in cloud backup (user must export manually) | | Search | Full‑text, faceted filters | Semantic search still in development | | Extensibility | Plugin API, SDK | Requires some programming knowledge | | Pricing | Free tier generous | Enterprise features require custom pricing |

Overall, Kept strikes an admirable balance between powerful functionality and user autonomy. The main trade‑off lies in the need for manual export or installation of the browser extension, which might deter less technical users. However, the benefits—particularly for developers, researchers, and privacy‑conscious individuals—are compelling.

12. Conclusion

In an era where AI chatbots are becoming integral to everyday work, the accumulation of conversational data can quickly spiral into chaos. Kept offers a thoughtful, developer‑friendly solution that transforms this chaos into an organized, searchable, and reusable knowledge base—all while keeping the data on the user’s own machine.

By embracing Markdown as the lingua franca of its archives, Kept ensures compatibility with the widest array of tools and workflows. Its architecture—rooted in local storage, robust indexing, and secure encryption—makes it suitable for both individuals and regulated enterprises.

If you find yourself juggling multiple AI conversations across platforms, feeling the weight of lost context, or worrying about data privacy, Kept warrants a closer look. With its forthcoming semantic search, collaborative features, and growing plugin ecosystem, it is poised to become a cornerstone of personal and professional AI knowledge management in the coming years.