Kept: A Ground‑breaking Tool for Organizing AI Conversations

Kept has emerged as a fresh entrant in the growing ecosystem of tools that let users capture, manage, and reuse the output from popular AI chat services such as ChatGPT, Claude, Gemini, Grok, and Kimi. The idea behind Kept is deceptively simple: save every AI conversation as a local Markdown file and provide a lightweight desktop application that lets you search, filter, and interlink those files. However, the implementation of this concept is surprisingly sophisticated and offers a powerful workflow for anyone who frequently interacts with AI models—whether as a developer, researcher, writer, or everyday productivity user. In this summary we’ll walk through the full arc of the Kept article, covering its motivation, core features, technical underpinnings, user experience, market positioning, and the broader implications for AI‑centric workflows.

1. Why a New Tool is Needed

1.1 The Proliferation of AI Conversations

Since the launch of ChatGPT in 2023, the number of conversations users have with AI systems has exploded. According to OpenAI, daily active users reached 10 million by early 2024, and the volume of generated content—ranging from code snippets to creative writing, from data analysis to legal drafting—has outpaced many traditional content‑management solutions. Most of this content is stored in the cloud and tied to a particular platform or API. While that works for occasional queries, it becomes cumbersome when a user needs to reference past interactions or repurpose a segment of a conversation for a new project.

1.2 Existing Solutions Fall Short

Several tools have been created to address this pain point: browser extensions that capture chat logs, notebook‑style solutions that embed AI outputs into Jupyter notebooks, and enterprise‑grade knowledge‑base platforms that aggregate content from multiple sources. Yet most of these options either suffer from limited search capabilities, require an ongoing subscription, or impose a cloud‑only workflow that can compromise privacy or speed. In contrast, Kept positions itself as a purely local, Markdown‑based solution that gives users complete ownership of their AI “library.”

1.3 The Vision Behind Kept

The creators of Kept identified a common workflow gap: “I had a conversation with ChatGPT that solved a problem, but I couldn’t find it again later because it was buried in a chat window or in a PDF.” Their vision was to make AI conversations behave like any other text‑based asset—indexable, searchable, linkable, and portable—without forcing users into proprietary ecosystems.

2. Core Idea: Markdown‑Based Archives

2.1 Why Markdown?

Markdown is the lingua franca of documentation, note‑taking, and code‑sharing communities. Its lightweight syntax is easily readable in plain‑text editors, yet it supports rich formatting when rendered in dedicated viewers or web interfaces. By converting each AI conversation into a Markdown file, Kept allows:

• Human readability: Anyone can open the file in Notepad, VS Code, or any editor without a GUI.
• Portability: Markdown files can be committed to Git, stored in cloud sync services, or shared via email.
• Extensibility: Existing Markdown‑based tools (e.g., Obsidian, Hugo) can now index and link Kept conversations seamlessly.

2.2 File Structure

A typical Kept conversation file follows this layout:

# Conversation with Claude – 2024‑05‑20 14:32:11

## User Prompt
...

## Claude Response
...

## Follow‑Up Exchange
...

> Note: This conversation was captured from Claude’s web interface via the Kept extension.

The top‑level heading includes the AI model name and timestamp, followed by sub‑sections for each turn in the chat. This deterministic structure facilitates automated parsing and indexing.

2.3 Local Storage and Privacy

Kept stores the entire archive on the user’s hard drive under a user‑defined folder. The default path is ~/Kept/Archive, but this can be moved to an encrypted drive or a network share. Because the data never leaves the device unless the user explicitly uploads it, Kept offers a privacy‑first approach—especially valuable for users working on sensitive code or research.

3. The Desktop App: Search, Browse, and Connect

3.1 Overview

While the Markdown files themselves are accessible, the true power of Kept lies in its companion desktop application. Built on Electron, the app runs on Windows, macOS, and Linux, providing a unified interface that turns the flat file system into an interactive knowledge base.

3.2 Search Engine

The search component is arguably the most praised feature in the article. Kept employs full‑text indexing powered by the lunr library, enabling instant retrieval even for archives containing tens of thousands of conversations. Users can:

• Search by keyword, phrase, or regex.
• Filter results by model (ChatGPT, Claude, Gemini, etc.), date range, or file path.
• Apply fuzzy matching to catch typographical variations or synonyms.

The search results are displayed in a two‑column view: a list of matching conversation snippets on the left and a preview pane on the right. Clicking an item expands the entire Markdown file, preserving the original formatting.

3.3 Browsing and Tagging

Kept also offers a hierarchical browsing view that mirrors the file system structure. Users can drag and drop files into folders, rename them, or attach tags via a custom metadata file (_meta.yml). Tags work like hashtags in social media: applying #python or #UX allows you to instantly filter conversations related to a particular topic.

The tagging system is integrated with the search bar; entering #python in the search field will display all conversations tagged with Python. The UI also supports multi‑tag queries, e.g., #python AND #debugging.

3.4 Linking Conversations

One of the more advanced features is the ability to link conversations together, turning the archive into a knowledge graph. Each Markdown file can contain Markdown‑style links ([see conversation about refactoring](/path/to/convo.md)). The desktop app renders these links as clickable elements that navigate to the target file. It also visualizes the link network in a graph view: nodes represent conversations, and edges denote links.

The graph view is interactive: users can zoom, pan, and filter by tag or model. By traversing the graph, a user can discover how a line of code or a conceptual thread evolved over multiple conversations.

3.5 Reuse and Export

Kept includes a reuse button that lets you copy selected text or entire conversations into the clipboard. Moreover, the app can export selected conversations as:

• Plain Markdown (.md).
• PDF via a built‑in renderer.
• JSON for integration with external tooling.

When exporting to PDF, Kept applies a simple but clean CSS theme to preserve readability.

4. Integration with AI Platforms

4.1 Browser Extension

Kept’s workflow starts with a browser extension that can be installed in Chrome, Edge, or Firefox. The extension injects a small UI overlay into the chat window of supported AI services. When a conversation is finished or paused, the user clicks the “Save to Kept” button. The extension then:

1. Captures the chat DOM.
2. Formats it into Markdown via a templating engine.
3. Sends the file to the local Kept server via a REST endpoint (http://localhost:12345/api/save).
4. Optionally tags the conversation based on user input or the extension’s heuristics (e.g., “#code”, “#research”).

The extension is open‑source, and the article notes that developers can fork it to add support for additional AI platforms or custom tagging workflows.

4.2 Supported Models

Kept currently supports the following AI platforms out‑of‑the‑box:

• ChatGPT (OpenAI)
• Claude (Anthropic)
• Gemini (Google)
• Grok (Cohere)
• Kimi (XAI)

The article highlights how each platform’s interface is slightly different, but Kept’s abstraction layer normalizes the data extraction across them. Users can also manually copy the conversation text into a .md file, and Kept will still index it.

4.3 API Access

Beyond the browser extension, Kept provides a lightweight local API for advanced users. The API exposes endpoints to:

• Query the search index.
• Import Markdown files programmatically.
• Delete or rename conversations.
• Retrieve the entire knowledge graph in JSON.

The article notes that the API is documented with Swagger UI, making it accessible to developers who wish to integrate Kept into CI/CD pipelines or custom workflows.

5. Technical Architecture

5.1 Electron + Node.js

The desktop app is built on Electron, which bundles Chromium and Node.js. This allows Kept to leverage web technologies for UI while having direct access to the file system. The main process handles indexing and the API, while the renderer process renders the UI.

5.2 Indexing Engine

Kept’s indexing engine uses Lunr.js to build a full‑text index in memory. When the app starts, it scans the archive folder, parses Markdown files, and updates the index. Because Lunr stores the index in a JavaScript object, queries run in milliseconds. The article points out that the app also serializes the index to disk on exit, so startup times remain low even for large archives.

5.3 Data Integrity and Sync

The article describes a checksum mechanism: each conversation file’s MD5 hash is stored in a kept-index.json file. On subsequent scans, Kept checks for changes. If a file is modified, the index is updated; if a file is deleted, the index removes it automatically.

Kept does not perform any background sync. However, users can export the kept-index.json and the Markdown files to a Git repository for version control. The article includes a Git hook example that automatically updates the index when the repository is cloned.

5.4 Security

Because Kept stores data locally, there is no risk of accidental leaks through the app itself. Nevertheless, the article highlights that the extension runs in a sandboxed environment, and the desktop app does not expose any network ports except the local loopback API. For added security, users can enable encryption for the archive folder by integrating with tools like VeraCrypt or BitLocker.

6. User Experience (UX) Evaluation

6.1 Onboarding

The onboarding flow is intentionally minimal. When the user first opens Kept, a wizard prompts them to set the archive path, install the browser extension, and optionally run a quick search test. The article praises the onboarding for not overwhelming new users with jargon or optional features.

6.2 Interface Design

Kept adopts a dual‑pane design: the left pane lists conversations or search results, while the right pane renders the Markdown preview. The UI uses a dark theme by default, with a light theme toggle. Custom CSS can be applied to match user preferences.

The search bar is fixed at the top and supports advanced queries: model:chatgpt date:>2024-01-01 #python. The article notes that users love the ability to combine tags, filters, and keyword searches in a single query.

6.3 Responsiveness

Because Kept’s indexing runs in memory, the app remains responsive even with 20,000 conversations. The article reports that typical search times are under 50 ms, and opening a file takes less than 100 ms.

6.4 Customization

Users can create custom snippets that are automatically inserted into new Markdown files. For example, a developer might add a standard header that includes a license notice or a reference to the AI model’s version. The article shows screenshots of the snippet manager, which is a small but powerful feature for teams.

7. Use Cases and Success Stories

7.1 Researcher: Tracking Scientific Explorations

A computational biology researcher used Kept to archive over 3,000 AI conversations that helped troubleshoot bioinformatics pipelines. By tagging each conversation with #RNASeq, #python, or #Docker, the researcher could filter by topic and quickly locate the exact step where the AI suggested a particular library update. The graph view revealed that several conversations were connected by shared code snippets, which helped the researcher identify a common source of bugs.

7.2 Freelance Writer: Managing Multiple Projects

A freelance copywriter working for various brands used Kept to keep separate archives for each client. By tagging conversations with the client name and project code, the writer could switch contexts instantly. The app’s export to PDF feature allowed the writer to produce polished drafts directly from the conversation log, reducing the need to copy-paste into word processors.

7.3 DevOps Engineer: Automating Infrastructure Tasks

A DevOps engineer integrated Kept’s API into an internal monitoring dashboard. Whenever a new AI conversation included an Ansible playbook, the engineer’s automation script parsed the Markdown file, extracted the playbook block, and ran a linting step before committing it to the repository. This reduced the risk of syntactic errors in infrastructure code.

8. Pricing and Licensing

8.1 Free vs. Paid Tiers

Kept is free for individuals, with no usage limits or cloud integration. The paid tier—Kept Pro—adds optional cloud sync (via end‑to‑end encrypted backup), priority support, and API rate‑limit increases. As of the article’s release, Kept Pro costs $4.99 per month or $49.99 per year, which the article describes as “affordable for small teams and freelancers.”

8.2 Open Source Commitment

Kept’s core is open source under the MIT license. The article highlights that the repository includes the extension, desktop app, and API, making it possible for companies to host a self‑managed instance. The open‑source nature also fosters community contributions, such as new AI platform adapters or advanced graph visualizations.

8.3 Enterprise Options

For larger organizations, Kept offers a Custom Enterprise Edition that can run on the company’s internal network, support single‑sign‑on (SSO), and provide an audit log of changes to conversations. The article notes that enterprise customers can negotiate volume discounts and dedicated support.

9. Competitive Landscape

9.1 Direct Competitors

• ChatGPT Notepad: A Chrome extension that saves chat logs to local storage. However, it lacks a desktop search app and offers limited formatting.
• AI Archive (by XAI): A web‑based solution that offers cloud storage and tagging, but it locks users into a proprietary backend.
• Obsidian AI Plugins: The Obsidian community offers AI plugins that integrate with GPT APIs, but these primarily function within the Obsidian ecosystem and rely on markdown notes.

Kept’s unique selling proposition is the combination of local Markdown storage, robust indexing, and an interactive graph.

9.2 Indirect Competitors

• Notion AI: A feature of Notion that captures AI responses but stores them in a proprietary database.
• GitHub Copilot Labs: Offers AI suggestions but does not provide a conversation archive.

Kept differentiates itself by focusing on permanent, portable, and searchable archives rather than transient AI assistance.

10. Criticisms and Potential Improvements

10.1 Limited AI Model Support

While Kept supports the major players, the article points out that some niche models—like certain specialized language models for finance—are not yet integrated. Future updates could provide an open API for users to add support for custom AI providers.

10.2 Extension Dependency

The article notes that Kept’s current workflow relies on a browser extension. If an AI platform updates its UI or changes the DOM, the extension may break. A possible improvement would be to offer a CLI capture tool that users can run in a headless browser environment.

10.3 Graph Visualization Depth

The graph view, though functional, is relatively basic. Users have requested more advanced features like clustering by tag, time‑based animations, or export to graph databases. Adding integration with tools like Neo4j or GraphQL could enhance this.

10.4 Collaboration Features

At present, Kept is largely a personal tool. The article mentions that collaborative tagging and sharing are under development. Future releases might include shared archives or read‑only links that can be distributed to collaborators.

11. Future Roadmap

11.1 AI‑Driven Summaries

Kept plans to integrate a feature where the user can automatically generate a concise summary of a conversation using the same AI platform that produced the original content. The summary would appear as a preview pane, allowing quick skimming.

11.2 Automatic Tagging via NLP

Leveraging machine learning, Kept will automatically assign tags based on content. The article outlines a prototype using spaCy to extract entities and topics, which will help users who otherwise struggle to manually tag every conversation.

11.3 Cross‑Platform Mobile Companion

A mobile app is in the pipeline, enabling users to search their archive on the go and view conversation snapshots. This would expand Kept’s usability beyond the desktop.

11.4 Integration with IDEs

Kept is exploring integration with VS Code and JetBrains IDEs to allow developers to invoke Kept’s search and import directly from the editor. The article shows an early mock‑up of a VS Code sidebar that lists relevant conversations for a selected code snippet.

12. The Broader Implications for AI Workflows

12.1 Treating AI Conversations as First‑Class Citizens

Kept embodies a philosophy that AI conversations should be treated like any other document: indexable, versioned, and reusable. This is a significant shift from the current model where AI outputs are often discarded after use. By giving AI conversations a permanent home, Kept helps users build knowledge bases that grow over time, reducing redundancy and accelerating problem solving.

12.2 Empowering Privacy‑First Users

The article underscores how Kept’s local storage model resonates with privacy advocates and industries with strict compliance requirements (e.g., legal, healthcare). The ability to keep data offline eliminates the risk of inadvertent exposure via third‑party cloud services.

12.3 Democratizing AI Knowledge Management

Previously, only large enterprises could afford dedicated knowledge‑management systems. Kept offers a low‑cost, low‑friction alternative that even freelancers can adopt. By open‑source licensing, it invites community contributions, fostering an ecosystem that can adapt to diverse needs.

13. Conclusion

Kept is more than a niche tool; it is a paradigm shift in how we interact with AI systems. By capturing conversations as Markdown files and providing a robust desktop interface for search, browsing, and linking, Kept turns the chaotic stream of AI interactions into a structured, searchable, and reusable knowledge base. Its emphasis on local storage and privacy, combined with its integration across multiple AI platforms, positions Kept as a compelling solution for developers, researchers, writers, and any professional who relies on AI for problem solving.

The article presents a clear, thorough overview that balances technical depth with practical use cases. It demonstrates that Kept’s core value lies in its simplicity—capturing a conversation is just a button click—while its advanced features—graph visualizations, tagging, API access—offer enough depth for power users. As AI becomes increasingly integral to daily workflows, tools like Kept will become essential components of the modern knowledge‑worker’s toolkit.