
TIMPs (Trustworthy Interactive Memory Partner System) is an open-source AI memory agent that revolutionizes how users interact with language models by providing persistent contextual memory across sessions. Designed for developers, researchers, and anyone who uses AI assistants repeatedly, it remembers facts, goals, preferences, and reflections from every conversation. The core value is eliminating the friction of reestablishing context each session: users describe their tech stack, project details, or personal preferences once, and TIMPs stores this information in a structured 14-field schema with importance scoring and vector embeddings. It can run fully locally with Ollama for zero cloud dependencies or integrate with OpenAI GPT-4 and Google Gemini. This flexibility makes it suitable for both privacy-critical and cloud-optimized environments, all while being free and open source under the MIT license.
The primary problem that TIMPs addresses is the lack of persistent context in standard AI chat interfaces. Users engaging in long-term projects often need to repeat themselves across sessions, which is inefficient and error-prone. TIMPs eliminates this friction by automatically recording and retrieving contextual information. After each conversation turn, the Reflection component analyzes the exchange, identifies key facts, and stores them with an importance score ranging from one to five stars. These memories are deposited into a PostgreSQL LongTermStore for exact keyword matching and a Qdrant VectorStore for semantic similarity search. When a user returns to a session, they simply use the `!blame` command to search for relevant memories. The dual retrieval shows both literal matches and semantically similar entries, along with their importance and retrieval frequency. This ensures that even if the exact phrasing changes, the system can surface the right context, making ongoing interactions seamless and highly productive.
A standout feature of TIMPs is its persistent memory system built on a 14-field schema that organizes each stored fact by type (explicit, reflection, goal, preference, etc.), importance score (one to five stars), project context, timestamp, and retrieval count. This rich metadata enables nuanced retrieval: for example, high-importance reflections are given priority over low-importance explicit facts. The Reflection component runs automatically after every conversation turn, analyzing the exchange to extract key information and assign an importance score. Users also have the option to explicitly store memories by stating them directly. All memories are stored simultaneously in PostgreSQL for exact SQL matching and in Qdrant for vector similarity, ensuring both precise and semantic recall. The `!audit` command provides a transparent view of the last ten stored memories with full metadata, allowing users to verify what has been learned and manage their memory store effectively.
admin
TIMPs features a powerful dual-mode search that combines SQL keyword matching (ILIKE) with Qdrant vector similarity. When a user issues the `!blame` command, the system searches the PostgreSQL LongTermStore using SQL ILIKE queries for exact keyword matches, and simultaneously applies cosine similarity search on the 1536-dimensional Qdrant embeddings. The results from both searches are merged, deduplicated, and presented with importance stars and retrieval counts. This hybrid approach ensures that even if a memory uses different wording, the vector search can find semantically related entries. For example, searching for 'frontend framework' might return a memory about 'React' if they are contextually close. This dual-mode retrieval makes TIMPs extremely effective at surfacing relevant memories from diverse user interactions.
Project isolation ensures that memories are scoped per project, preventing cross-contamination between different codebases or client environments. When using the CLI, users specify a project ID, and all stored memories carry this tag. Retrieval queries respect the project context, so memories from Project A never appear while working on Project B. For situations requiring absolute privacy, ephemeral mode can be toggled with `--mode ephemeral`. In this mode, no data persists beyond the current session; all memory lives in RAM and disappears when the session ends. This is ideal for sensitive discussions or one-off debugging. Additionally, TIMPs is model agnostic, supporting OpenAI GPT-4, Google Gemini, and local Ollama models. Users can switch between providers on the fly with the `--provider` flag without losing any stored context.
TIMPs follows a modular architecture that processes user input through three stages: Planning, Execution, and Reflection. The Planner breaks down complex requests into manageable steps, the Executor runs tools like file access and web search, and the Reflection component extracts memories from the turn. The Memory System is layered: a ShortTermStore maintains a rolling context window within a token budget, a LongTermStore in PostgreSQL records all persistent facts with the 14-field schema, and a VectorStore in Qdrant enables semantic search. Users can interact via three interfaces: a terminal-based TUI/CLI, a web UI that connects to a local server on localhost:3000, or a REST API. The single-line installation script (`curl -fsSL https://raw.githubusercontent.com/Sandeeprdy1729/timps/main/install.sh | bash`) sets everything up quickly.
Concrete use cases for TIMPs abound in development and research contexts. A developer can start a session, declare their project stack (e.g., React, TypeScript, Zustand), and in future sessions simply use `!blame React` to instantly retrieve that profile along with any related preferences, such as using functional components. Researchers conducting long-term investigations can build a knowledge base across sessions: each new finding is stored with context and can be queried later, connecting disparate pieces of information. The `!forget` command provides a safe deletion mechanism with a preview and confirmation step, ensuring no accidental loss of important memories. The `!audit` command gives full visibility into the stored memories. The outcome is a continuously personalizing AI that reduces repetitive work, speeds up problem-solving, and increases the coherence of multi-session dialogues.
TIMPs targets developers, AI researchers, technical project managers, and anyone who interacts with language models repeatedly and desires persistent context. It runs on Linux, macOS, and Windows, requiring PostgreSQL and Qdrant instances for storage. The supported model providers are OpenAI, Google Gemini, and Ollama, allowing both cloud and fully local operation. TIMPs is open source under the MIT license, with the complete codebase available on GitHub for auditing and contributions. There are no paid tiers; it is completely free. The easy one-line install and comprehensive docs make it accessible to beginners while offering depth for power users. In summary, TIMPs delivers the first truly persistent memory layer for AI agents, transforming stateless chatbots into context-aware assistants that remember what matters, making it an essential tool for productive AI workflows.
Developers working on multiple projects who need to retain context about their tech stack and preferences. Researchers conducting long-term investigations across AI sessions. Team leads managing client-specific memory isolation. AI enthusiasts and early adopters experimenting with persistent memory agents. Privacy-conscious users seeking a fully local AI memory solution. Anyone who interacts with language models repeatedly and wants to eliminate the need to repeat themselves.
Updated 2026-02-28