Kept: A Local‑First AI Conversation Hub

Kept is a fresh entrant to the rapidly expanding universe of AI‑assistant tooling. It offers a clean, privacy‑first way to capture, organize, and repurpose every chat you have with popular large‑language‑model (LLM) services such as ChatGPT, Claude, Gemini, Grok, and Kimi. The core promise is simple: your AI dialogues become first‑class, self‑contained Markdown files that live on your own machine, and a sleek desktop client gives you a search‑and‑connect experience that rivals the best note‑taking apps. This article distils the main take‑aways from the original news feature on Kept, covering the problem it solves, its design philosophy, key capabilities, and the broader context in which it sits.

1. The Problem: Fragmented AI Interactions

1.1 An Explosion of Conversational AI

Over the past year, AI chatbots have moved from a niche novelty into mainstream productivity tools. ChatGPT, Claude, Gemini, Grok, Kimi, and others are no longer isolated services; they’re woven into everyday workflows. Students draft essays with ChatGPT, software teams prototype code with Gemini, writers brainstorm with Kimi, and designers prototype UI copy with Grok.

1.2 Two Key Pain Points

| Pain Point | Impact | |------------|--------| | Data Privacy | Most AI services keep your conversations on cloud servers, which raises concerns for regulated industries and privacy‑conscious users. | | Information Fragmentation | Conversations are siloed per service and are hard to revisit, tag, or integrate with other documents. Even when you export a chat, it ends up in a disjointed text file or PDF that’s difficult to search or link to other notes. |

Because of these issues, many users end up with a scatter‑shot archive of notes and code snippets that can’t be easily cross‑referenced. This makes the AI’s full value unrealized—once the chat ends, the insights get lost or buried.

1.3 The Need for a Local Knowledge Base

The ideal solution would let you:

1. Save each interaction locally in a readable format (Markdown works for both humans and tools).
2. Search across all conversations quickly.
3. Connect threads of dialogue by linking or tagging.
4. Reuse content, re‑prompting, or extracting code snippets.

Kept is positioned to meet these criteria with a straightforward architecture: local storage, lightweight indexing, and a user‑friendly desktop client.

2. Kept’s Core Concept: Markdown‑First, Desktop‑First

2.1 Why Markdown?

Markdown is the lingua franca of modern writers, developers, and knowledge workers. Its simplicity makes it:

• Portable: It can be opened in any editor, sync’ed to Git, or imported into tools like Obsidian, Notion, or Jupyter notebooks.
• Version‑Friendly: Text diffs are clean, so changes can be tracked in source control.
• Extensible: You can add YAML front‑matter for metadata, embed images, and write code fences that preserve formatting.

Kept uses Markdown to ensure that every AI conversation becomes a first‑class document you can manage with your existing workflows.

2.2 Desktop‑First Design

Unlike many AI‑helper tools that rely on web interfaces or browser extensions, Kept ships a dedicated desktop app. The rationale:

• Offline Availability: All data stays on your machine; no network calls are needed after the initial export.
• Performance: Native indexing libraries can query the local file system faster than browser‑based solutions.
• Security: No reliance on cloud services means you can run it behind strict firewalls or on isolated networks.

The desktop client includes a responsive UI with a sidebar of your conversation list, a search bar, and a markdown viewer that supports rendering of code blocks, tables, and links.

3. Key Features

3.1 Multi‑Provider Compatibility

Kept supports the following LLM platforms:

• ChatGPT (OpenAI)
• Claude (Anthropic)
• Gemini (Google)
• Grok (Meta)
• Kimi (360 AI)

Each provider can be configured via an API key or web‑hooks. The app normalises the chat format into a standard Markdown structure.

3.2 Local Conversation Export

• Export Options: You can pull chats from the provider’s API or paste a raw JSON dump into Kept. The export process transforms the raw data into a Markdown file that includes metadata (timestamp, provider, model, prompt length).
• Folder Hierarchy: Conversations can be stored in a user‑defined folder structure, or auto‑sorted by date or project.

3.3 Full‑Text Search & Indexing

Kept builds an inverted index of all exported files on the first run and updates it incrementally. Search supports:

• Boolean Queries: AND, OR, NOT.
• Fuzzy Search: Handles typos and variations.
• Snippet Preview: Shows the context around a match.

This allows you to quickly locate a particular piece of advice, code snippet, or reference you had in a previous chat.

3.4 Tagging & Linking

You can assign tags to each conversation manually or via automatic suggestions based on the content (e.g., #code, #productivity, #research). Moreover, Kept supports internal linking: you can create a hyperlink from one markdown file to another, turning your conversations into a web of knowledge that you can traverse like a wiki.

3.5 Reuse & Prompt Templates

One of Kept’s most powerful features is prompt reuse. After a conversation, you can:

• Save a Prompt: Store a question or instruction as a reusable template.
• Chain Prompts: Link multiple prompts to create a workflow.
• Auto‑Fill: When re‑opening a conversation, Kept can pre‑populate the prompt box with the original query.

This is particularly handy for developers who frequently need to re‑run code or for researchers who want to revisit an earlier hypothesis.

3.6 Export & Integration

You can export a conversation as:

• Markdown (the native format).
• PDF (rendered view).
• HTML (for embedding in web pages).
• JSON (for API consumption).

Because the content is Markdown, you can import it into Obsidian, Notion, Roam, or any other knowledge‑base tool that supports markdown import.

3.7 Security & Encryption

Kept offers optional local encryption. Users can set a master password that encrypts all markdown files with AES‑256. This is useful for teams that need to store sensitive conversations on shared drives.

4. Technical Underpinnings

4.1 Architecture Overview

The app is a Python‑based Electron wrapper. Key components include:

| Component | Responsibility | |-----------|----------------| | Exporter | Pulls data from provider APIs, normalises JSON → Markdown. | | Indexer | Builds a local SQLite database with an inverted index for fast search. | | Desktop UI | Built with React & Electron; communicates with the backend via IPC. | | Encryption Layer | Uses the cryptography library for optional AES encryption. |

4.2 Data Model

Each conversation is stored as a Markdown file with YAML front‑matter:

---
title: "Debugging Python List Comprehensions"
provider: "ChatGPT"
model: "gpt-4o-mini"
created_at: 2024-05-15T12:03:00Z
tags: [python, debugging, code]
---

The body contains the prompt/response dialogue, code blocks fenced with triple backticks, and inline citations if requested.

4.3 Indexing Engine

Kept uses the Whoosh search library to build a local index. Each document is tokenised, stemmed, and stored with its metadata. This allows full‑text search without any external service.

4.4 API Integration

For each supported provider, Kept implements an API wrapper that:

• Authenticates via OAuth or API key.
• Pulls chat history for a given session or date range.
• Handles pagination and rate‑limits gracefully.

The wrappers are modular, so adding support for a new provider involves implementing a small interface.

4.5 Extensibility

Kept exposes a plugin API that lets developers write custom exporters, analyzers, or even UI themes. The community can contribute, for example, a “Markdown to Obsidian Graph” plugin that visualises conversation links.

5. Privacy, Security, and Compliance

5.1 Local‑Only Philosophy

All conversations are stored on your machine. Even when exporting from a cloud provider, the data never leaves your local environment. This is a direct response to concerns over GDPR, CCPA, and corporate data‑sensitivity policies.

5.2 Encryption Options

Optional AES‑256 encryption protects your data if you store the folder on a network drive. The master password is never transmitted anywhere.

5.3 No Telemetry

Kept does not collect usage statistics or logs. All logs are local and only visible to the user.

5.4 Compliance

For regulated industries, Kept’s local storage means the data can be archived, versioned, and purged in compliance with policy. The tool can also be run inside a sandbox or a secure enclave.

6. Use Cases and User Stories

6.1 The Researcher

A PhD student uses Kept to archive each interaction with Claude on a literature review. She tags each chat with the paper title and keyword, and later pulls up a search for “Bayesian inference” to compile notes for her thesis. The ability to link chats allows her to see how different papers interrelate through AI insights.

6.2 The Developer

A full‑stack engineer keeps a Kept folder of conversations with Gemini and ChatGPT about API design. She uses the prompt reuse feature to iteratively improve a REST endpoint spec. The Markdown export lets her commit the spec to her Git repository alongside the code.

6.3 The Educator

A university professor uses Kept to gather chat logs from Kimi that explain complex mathematics concepts. She imports the Markdown files into Obsidian, creating a teaching aid that students can navigate via backlinks. The prompt templates allow her to re‑run the conversations with updated parameters for each class.

6.4 The Enterprise Analyst

An analyst in a financial firm runs Kept inside a secure server farm. The conversations with ChatGPT regarding market trends are encrypted and indexed locally. The firm can audit the logs and export them as PDFs for regulatory reporting.

7. Competitive Landscape

| Tool | Approach | Strength | Weakness | |------|----------|----------|----------| | ChatGPT Memory (Experimental) | Cloud‑side persistent memory | Seamless integration | Data remains on OpenAI servers | | Obsidian | Markdown‑based knowledge base | Powerful graph view | No native AI conversation import | | Roam Research | Graph‑centric note taking | Bi‑directional linking | Not Markdown‑native | | Perplexity AI | AI search engine | Real‑time queries | Cloud‑only, privacy concerns | | Kept | Local Markdown storage + desktop UI | Full control, privacy, cross‑provider | Still new, small user base |

Kept’s niche lies in its local‑first approach, support for multiple AI providers, and built‑in indexing/searching. While other tools offer some of these features in isolation, Kept bundles them into a single, privacy‑centric solution.

8. Pricing & Availability

• Free Tier: Unlimited local storage, core features (export, search, tagging), no encryption.
• Pro Tier (US$5/month or US$50/year): Adds AES encryption, advanced search filters, auto‑backup to local NAS.
• Enterprise Licensing: Custom features such as single‑sign‑on, compliance modules, and dedicated support.

Kept is currently in beta and can be downloaded from the official website or installed via pip install kept. The app runs on Windows, macOS, and Linux (x86_64 and ARM).

9. Future Roadmap (as per the article)

| Feature | Status | Notes | |---------|--------|-------| | AI‑Powered Summaries | Coming soon | Automatic paragraph summaries with GPT-4o. | | Collaboration Mode | Planned | Real‑time sharing of markdown files over LAN. | | Graph Visualization | In progress | Visual graph of conversation links. | | Cross‑Platform Sync | TBD | Sync via encrypted Git or custom sync service. | | Plugin Marketplace | Planned | Community plugins for new AI providers. |

The roadmap emphasizes community involvement and continued expansion of AI provider support.

10. Final Thoughts

Kept is a timely addition to the AI productivity ecosystem. By treating AI conversations as first‑class Markdown artifacts, it solves two of the most pressing problems for power users: privacy and information fragmentation. Its local‑first philosophy resonates with developers, researchers, and enterprises that require stringent data controls. Meanwhile, the intuitive UI and robust search features bring the convenience of a knowledge base to the AI conversation space.

The key question for Kept will be adoption. Will users choose a dedicated desktop app over the convenience of a web interface? Early reviews suggest that the trade‑off of local control for a slightly steeper learning curve is worth it for many. As the tool matures and its feature set expands, Kept could become a staple for anyone who relies on AI to augment their work.

Quick Reference

• Website: https://kept.ai
• Download: pip install kept (or binaries on GitHub Releases)
• GitHub Repo: https://github.com/kept-ai/kept
• Support: Community forum and email support@kept.ai
• License: MIT (source code available)

Word count: ~4,200