OpenViSTAI · Agents · Blockchain · Crypto
Submit a project
Menu
Agent Memory & RAG

Logosdb

LogosDB is a C/C++ semantic vector database that stores embedding vectors with optional text and timestamps, then performs approximate nearest-neighbor search to retrieve matching records.

Explore the practical guide ↓

Independent OpenViST project profile, based on linked sources.

Logosdb — OpenViST project profile in Agent Memory & RAG.
OpenViST project illustration. See the linked sources for product details.
Understand the project

Practical overview

When it fits

Use LogosDB when an application needs a locally integrated store for embedding-based memory retrieval and can provide its own embedding generation. It is a fit for single-process use rather than a built-in remote database service.

Who it is for

  • Developers building AI-agent memory or retrieval-augmented generation into an application.
  • C, C++, or Python developers who can supply precomputed embedding vectors.

Documented uses

  • Store text and optional timestamps alongside embeddings.
  • Retrieve top-k semantically similar records using approximate nearest-neighbor search.
  • Restrict retrieval to a timestamp range.
  • Use a LangChain or LlamaIndex VectorStore adapter, or the documented MCP server integration for Claude Code.
Before you choose

Requirements & limits

The project is open source under the MIT license. The README documents Python installation through PyPI and source installation from a repository clone.

  • Embedding generation is external; callers provide float vectors.
  • The default inner-product distance requires L2-normalized vectors; cosine distance normalizes automatically.
  • Only one process may access a database at a time, though a single open handle is documented as thread-safe.
  • There is no built-in client-server support; remote access requires an application-provided wrapper.
  • The project describes itself as purpose-built for embedding-based memory retrieval rather than as a general-purpose vector database.

Check current requirements in the official documentation. Source-based guidance does not mean OpenViST has run or independently tested this project.

Source-based practical guide

Install LogosDB’s Python package and add or search semantic memories

Install the Python bindings, then use supplied embedding vectors to store text and retrieve nearest matches.

Before you start

  • Python 3.9–3.13 on Linux x86_64/aarch64 or macOS x86_64/arm64 for the documented binary wheels.
  • Pre-computed float embedding vectors; embedding generation is external.
  • Vectors compatible with the configured database dimension.

Steps

  1. Install the package with the command below, or build it from a repository clone with the command below.

    Documented command
    pip install logosdb
    Documented command
    pip install .

  2. Import logosdb in Python and use its bindings to open a database and perform the documented basic operations: Put(embedding, text, timestamp) and Search(query, top_k).

  3. For the default inner-product distance, L2-normalize vectors before insertion; alternatively, select cosine distance to have vectors normalized automatically.

Expected outcome

A Python application can store text metadata with embedding vectors and retrieve approximate nearest-neighbor matches.

Guide limitations

  • Embedding generation is not provided by the database; callers supply pre-computed float vectors.
  • A particular database can be accessed by only one process at a time, though that process may be multi-threaded.
Documentation 1 ↗
Source-based practical guide

Store and search semantic memories with the C++ wrapper

Create a dimensioned database, store a normalized embedding with text and timestamp metadata, and retrieve top matches.

Before you start

  • C++ application using the public interface in include/logosdb/logosdb.h.
  • Pre-computed float vectors of the configured dimension; the example uses 2048 dimensions.
  • For default inner-product distance, vectors must be L2-normalized before insertion.

Steps

  1. Include ` and construct logosdb::DB with a database path and dimension, as in logosdb::DB db("/tmp/mydb", {.dim = 2048});`.

  2. L2-normalize an embedding using logosdb::l2_normalize; when normalization succeeds, insert it with db.put(embedding, text, timestamp).

  3. Normalize a query vector and call db.search(normalized, top_k), then read result fields such as id, score, and text.

Expected outcome

The application stores embedding-backed text memories and receives nearest-neighbor search results with scores and associated text.

Guide limitations

  • Embedding generation is external; the caller provides float vectors.
  • Inner-product distance requires L2-normalized vectors. Cosine distance is documented as an alternative that normalizes vectors automatically.
  • A database supports only one accessing process at a time; the library does not include client-server support.
Documentation 1 ↗
COMPARE OPTIONS

Compare options for Vector search

These projects document a common task and share a project role. This is a source-based comparison, not an execution benchmark or a guarantee of interchangeability.

ProjectDocumented purposePlatformAccess and requirements
LogosdbStore text and optional timestamps alongside embeddings.CLI, Self-hostedThe project is open source under the MIT license. The README documents Python installation through PyPI and source installation from a repository clone.
KektordbSave and retrieve semantic memories across agent sessions.Self-hosted, ServerThe README describes self-hosted use and displays an Apache 2.0 license badge.
LongbowStore and retrieve dense or sparse vectors with HNSW search.Server
Evidence and transparency

Sources & review

Official repository ↗
Source record details
Source availability
Active
Sources checked
14 October 2026
Original website title
jose-compu/logosdb · Official homepage title · retained in its source language
How we review sourcesSuggest a correction