Hey guys,

I run a lot of autonomous agents and recently had a crew get stuck in a recursive tool error loop where it just kept retrying the same database query over and over, burning through credits before I caught it.

Over the last few days I built a lightweight reverse proxy in FastAPI to fix this.

You just change your base url to point to the gateway. It hashes tool calls in memory by function name and arguments. If it catches the agent repeating the exact same tool call three times, it cuts the stream immediately and returns a completion with finish reason stop so CrewAI terminates cleanly instead of retrying forever.

Latency overhead is under 35ms, keys are encrypted with AES 256, and it does not log your prompt contents.

Put up a free tier with 15 dollars of monitored spend if anyone wants to test it on their crews: https://circuit-breaker-sage.vercel.app/

Let me know what you think or if you run into any edge cases with your custom tools.

Wanted to share a project I've been working on to give local Ollama models persistent document memory without needing heavy vector databases.

It's called Hillock. The main problem I had with standard local RAG was that running document parsing and vector search chewed up so much VRAM that my actual Ollama model (like Llama 3 8B or Qwen) ran painfully slow.

With this:

• You drop in a doc, and it extracts facts in ~5 seconds using tiny sub-300MB models instead of an LLM.
• Facts go into an SQLite database.
• When you ask a question, it checks if the knowledge actually exists first using hypervector math. If you ask something outside your notes, it stops the model from hallucinating.

It has a /model command in the CLI that automatically detects whatever Ollama models you have pulled on your machine and lets you swap between them, plus an OpenAI-compatible API if you prefer using Open-WebUI.

Fits in under 1.2GB VRAM (or runs on CPU). Repo is open source: https://github.com/roandejager/Hillock

I built Hillock, a lightweight, local-first memory engine written in Python. It's designed to give local LLMs long-term memory without eating all your VRAM or relying on heavy vector databases.

How it's built:

• Extraction pipeline using fastcoref + lightweight HuggingFace bi-encoders (extracts facts without calling an LLM)
• SQLite database with WAL mode for storing Knowledge Graph triples
• Hyperdimensional Computing (HDC) similarity gating to mathematically stop hallucinations
• Built-in FastAPI server with an OpenAI-compatible endpoint
• Works on CPU or consumer GPUs (<1.2GB VRAM footprint)

Just released version 0.7. Check out the project here: https://github.com/roandejager/Hillock

Hey Python community!

I recently put together Hillock, a lightweight memory and retrieval engine written in Python that runs locally on edge hardware (<1.2 GB VRAM or pure CPU).

The core motivation was to create a memory layer for local models that does not hallucinate when it runs out of context.

Key parts of the project:

• 3-tier memory: SQLite for ground-truth facts, Hebbian synaptic weights for associative recall, and 10,000-D hypervectors for sub-millisecond context matching.
• Control-flow gating: If stored facts do not match a query, Hillock returns a fixed refusal string immediately. The local LLM is never called with unverified context.
• ColBERT-style MaxSim: We adapted late-interaction token scoring to discrete bipolar vectors using NumPy matrix math on CPU.
• Easy setup: Includes 1-click launchers for Windows and Linux/Mac, along with interactive CLI commands like /inspect, /status, and /model.

Feedback, ideas, and contributions are very welcome!

Hi everyone! I wanted to share a project I have been writing in Python: Hillock, an open-source memory engine designed to run completely offline on laptops and budget hardware.

I wanted to see if I could build a deterministic memory system without relying on heavy cloud APIs or external vector database services.

How the Python architecture works:

• Vector Symbolic Math (reservoir.py): Built entirely with NumPy to handle a 10,000-dimensional bipolar vector space. To keep similarity gating fast on standard CPUs, I implemented a Sub-Dimensional Projection Cascade that evaluates a 2,000-D slice first for early rejection, keeping latency under 1 second.
• Relational Fact Store (database.py): SQLite handles Subject-Predicate-Object triples with micro-batched transactions and stores bit-packed multi-hop path vectors as compact BLOBs.
• Synaptic Co-Activation (plasticity.py): Implements gradient-free Hebbian updates across turns with per-turn exponential decay.
• Local Extraction (talon_engine.py): A pipeline combining Fastcoref, MiniLM, and GLiREL with type-constrained schema validation and direction auto-correction.
• Interactive Console (main.py): Features real-time token streaming from local Ollama models, live hardware tracking, and inspection tools.

We also have a standalone 21-point test suite (verify_hillock.py) to test the math and database semantics with zero GPU requirement.

Everything is open-source under AGPL-3.0.

I would really appreciate any thoughts on the Python code layout or NumPy optimizations!

Hey LLM developers! I wanted to share a technical breakdown of the retrieval and gating architecture we just shipped in Hillock v0.6.0.

Hillock is a local, AGPL-3.0 neuro-symbolic memory engine built for edge hardware (<1.2 GB VRAM / CPU-only). Instead of standard dense vector embeddings, it combines an SQLite Knowledge Graph with 10,000-dimensional Vector Symbolic Architectures (VSA / Hyperdimensional Computing) and Hebbian associative memory.

The Problem with Query Bundling:
In earlier versions, query tokens were superposed (bundled) into a single hypervector. Because random vectors in 10,000-D space are quasi-orthogonal, query bundles grew in variance as question length increased, causing answerable multi-word queries to drop below our similarity gate.

How We Solved It in v0.6 (HYDRA):

1. Bipolar MaxSim: We implemented ColBERT-style token-level MaxSim directly over discrete bipolar vectors {-1, +1}^10000: MaxSim(Q, F) = (1 / N_q) * sum(max(CosSim(q_i, f_j)))
2. Sub-Dimensional Projection Cascade: Computing full pairwise dot products across 10,000 dimensions for every fact can bottleneck a CPU. We evaluate a 2,000-D subspace slice first to early-reject ~95% of candidates in ~0.5ms before evaluating the full vector.
3. Positional Permutation for Multi-Hop: Because Hadamard binding is commutative, we apply cyclic coordinate shifts Pi^k(v) at each hop depth to preserve trajectory ordering across 2-hop and 3-hop relational paths.
4. Control-Flow Gating: If MaxSim does not clear the calibrated threshold (0.55 raw cosine) with positive predicate intent, Ollama is never called.

In our unseeded 32-query benchmark, fast-eval finishes in 1.16s on a laptop CPU, achieving 54.5% retrieval accuracy and a 60% hard-negative block rate.

Repository and full mathematical breakdown: https://github.com/roandejager/Hillock

I would love feedback on the VSA math and how other developers are approaching sub-millisecond similarity gating on edge hardware!

Hey everyone! As agentic workflows grow more complex, maintaining reliable long-term state on local hardware becomes a real bottleneck. Dense vector databases frequently retrieve noisy context, and burning hundreds of tokens on LLM reflection passes just to filter out bad retrievals slows down local agent execution.

I built Hillock as an open-source experiment to provide a lightweight, deterministic alternative.

Key architectural concepts:

• Grounded Symbolic Facts: Memories are stored as Subject-Predicate-Object triples in SQLite, preventing vector drift and approximation errors.
• Programmatic Refusal Gate: Instead of prompting an agent to admit ignorance, Hillock uses a 10,000-D Hyperdimensional Computing (HDC) similarity gate. If no stored facts pass the threshold, the LLM call is blocked entirely.
• HYDRA Late-Interaction (v0.6): We adapted ColBERT-style MaxSim token scoring to discrete bipolar vectors using a 2,000-D Sub-Dimensional Projection Cascade. This eliminates query-length decay and completes retrieval in under 1 second on a standard CPU.
• Relational Path Permutations: Binds 2-hop and 3-hop paths during ingestion using cyclic coordinate shifts, enabling instant multi-step relational deduction.

Everything runs offline on edge hardware (<1.2 GB VRAM footprint, with pure CPU fallback).

GitHub project: https://github.com/roandejager/Hillock

I would love to discuss how the community views hybrid symbolic-connectionist memory for autonomous agents, and where pure vector search falls short in your agent pipelines.

Hey everyone! Over the past few months, I have been working on a personal experiment called Hillock: a lightweight, 100% offline memory engine designed for edge hardware.

Like many people experimenting with local AI, I was frustrated by how heavy standard vector databases are. They burn precious VRAM, suffer from semantic drift, and when you ask them something they do not know, the LLM still hallucinates a confident guess.

I wanted to see if I could build a deterministic, neuro-symbolic memory system that runs comfortably on a GTX 1070 or a basic CPU laptop.

Here is what powers it:

• SQLite Knowledge Graph: Stores ground-truth facts as relational triples (zero vector drift).
• Hebbian Synaptic Engine: Gradient-free associative learning that strengthens connections between concepts as you chat.
• 10,000-D Hyperdimensional Computing (HDC): Sub-millisecond similarity gating on CPU that blocks unanswerable questions before they ever reach the generator.

In our latest v0.6.0 release, we introduced HYDRA (ColBERT-style late-interaction MaxSim adapted for bipolar hypervector space) and multi-hop hypergraph path binding. Ingestion takes ~5 seconds, and retrieval across 32 queries finishes in under 1.2 seconds on a CPU.

We publish every benchmark openly on the README, including the versions where accuracy dipped during development.

Repo: https://github.com/roandejager/Hillock

I would love any feedback, code critique, or ideas from fellow builders!

Hey Ollama community!

Traditional local RAG setups can be surprisingly heavy on our GPUs. Running vector databases alongside 8B+ models just to parse text and maintain memory burns VRAM fast, and the LLM still tries to guess when it does not know the answer.

I built Hillock to solve this on budget edge hardware (tested on a GTX 1070 and pure CPU laptops).

How it works with Ollama:

• TALON Engine extracts structured knowledge triples locally without calling an LLM.
• Facts live in SQLite, associative links use Hebbian synaptic weights, and context matching happens in a 10,000-D hypervector space.
• Gating is pure control flow: If your question cannot be answered by verified facts, Hillock returns a hardcoded refusal in under 1ms. Ollama is never called, saving 100% of GPU compute on unanswerable questions.
• Ollama is only invoked at the very end to stream the grounded answer token-by-token. You can switch models live in the console using /model [name].

We just pushed v0.6.0, bringing late-interaction MaxSim gating and multi-hop relational path reasoning.

GitHub repo: https://github.com/roandejager/Hillock

If you run Ollama locally and want to experiment with alternative memory architectures, I would love for you to test it out and share your feedback!

hey everyone,

I updated my open source project Hillock (AGPL-3.0) to v0.2.2: https://github.com/roandejager/Hillock

Hillock is a privacy-first memory engine written in Python that replaces vector DBs with a SQLite Knowledge Graph, Hebbian Plasticity, and Hyperdimensional Computing math.

In v0.2.0, I created TALON—a non-generative CUDA tensor pipeline (Fastcoref + MiniLM + GLiREL) that extracts knowledge graph facts in sub-seconds on a GTX 1070 GPU without waiting for LLMs to generate JSON.

It's 100% local, offline, and open source under AGPL-3.0. Would love any feedback or thoughts!

Hey Python devs,

I wanted to share a personal project I've been building in Python called Hillock (AGPL-3.0): https://github.com/roandejager/Hillock

What It Does:

Hillock gives local AI applications a privacy-first Knowledge Graph memory. Instead of vector databases that lose exact factual context, Hillock uses a decoupled SQLite Knowledge Graph, Hebbian Plasticity, and CPU-bound Hyperdimensional Computing (Vector Symbolic Architectures) written in pure Python/NumPy.

How the Python Pipeline Works:

In v0.2.0, I built TALON—a non-generative ingestion pipeline:

1. Fastcoref: Resolves pronouns across paragraphs before chunking text.
2. SentenceTransformers (all-MiniLM-L6-v2): Pre-caches a 50-predicate taxonomy and routes top candidates per sentence in <2ms.
3. GLiREL (DeBERTa-v3): Performs single-pass zero-shot matrix classification in PyTorch CUDA memory.

On my benchmark harness (evaluate_hillock_PROTO_ish.py), it processed 32 sentences in 2.1 seconds of pure GPU execution on a GTX 1070 (<1GB VRAM footprint), reaching 50% retrieval accuracy.

Source code is 100% open source under AGPL-3.0. Would love to hear your feedback on the Python architecture!

Hey everyone,

I wanted to share my open source project Hillock (AGPL-3.0): https://github.com/roandejager/Hillock

Hillock is a local-first memory engine for AI that replaces vector databases with a decoupled SQLite Knowledge Graph, Hebbian Plasticity, and Hyperdimensional Computing (VSA math).

In v0.2.0, I built TALON—a non-generative CUDA tensor pipeline combining Fastcoref, MiniLM, and GLiREL zero-shot matrix classification. It ingests documents and extracts structured SPO triples in sub-seconds on an 8GB GTX 1070 GPU.

Everything runs 100% locally and offline. Code and benchmark scripts are on GitHub. Would love your feedback!

hey r/AutoGPT,

A major pain point when giving autonomous agents long-term Knowledge Graph memory is ingestion speed. If an agent uses generative LLMs (like Llama 8B or Qwen) to extract facts, it takes 15+ minutes per PDF waiting for token-by-token JSON generation and burns GPU VRAM.

I've been building Hillock, an open-source local memory engine (AGPL-3.0): https://github.com/roandejager/Hillock

In v0.2.0, I built TALON—a non-generative CUDA tensor pipeline that bypasses generative LLMs during ingestion:

1. Fastcoref resolves pronouns across full paragraphs first (so 'She' becomes 'Marie Curie').
2. MiniLM bi-encoders filter 50+ open-domain Wikidata predicates down to the top 10 for each sentence in <2ms.
3. GLiREL does single-pass zero-shot matrix classification to pull out [Subject, Predicate, Object] triples directly in GPU memory.

Because it's pure CUDA tensor math instead of token generation, it processed 32 sentences in ~2 seconds on my GTX 1070 while using <1GB VRAM, doubling retrieval accuracy to 50%.

It's 100% local, offline, and open source under AGPL-3.0. Would love to hear your thoughts on memory for autonomous agents!

Hey agenticAI,

A big bottleneck for long-term agent memory is ingestion latency. Extracting structured Knowledge Graph facts using generative LLMs takes minutes per document waiting for token-by-token JSON generation.

I've been building Hillock, an open-source local memory engine (AGPL-3.0): https://github.com/roandejager/Hillock

In v0.2.0, I created a non-generative tensor pipeline (TALON) for agent memory:

1. Fastcoref resolves pronouns across full paragraphs first.
2. MiniLM bi-encoders route top 10 dynamic Wikidata predicates in <2ms.
3. GLiREL zero-shot matrix classification extracts [Subject, Predicate, Object] triples directly in GPU memory.

It processed 32 sentences in ~2 seconds on a GTX 1070 (<1GB VRAM footprint), doubling retrieval accuracy to 50%.

Everything runs 100% locally and offline. Would love to hear how others are handling structured long-term memory for agents!

hey OpenSourceAI,

I've been building Hillock (AGPL-3.0), a privacy-first local memory engine in Python: https://github.com/roandejager/Hillock

Instead of vector databases that suffer from semantic hallucinations, Hillock uses a decoupled SQLite Knowledge Graph, Hebbian Plasticity, and CPU-bound Hyperdimensional Computing (HDC math) for hallucination defense.

In v0.2.0, I built TALON—a non-generative tensor pipeline using Fastcoref, MiniLM, and GLiREL. It extracts structured facts in sub-seconds on a consumer GTX 1070 GPU without token generation or cloud APIs.

It's 100% local, offline, and open source under AGPL-3.0. Would love any feedback or thoughts!

hey r/ollama,

I've been building a personal open source project called Hillock (AGPL-3.0) to give local LLMs a fast, privacy-first Knowledge Graph memory: https://github.com/roandejager/Hillock

A big pain point I kept running into when ingesting documents alongside local Ollama models was speed. Having an 8B LLM extract facts token-by-token takes 15+ minutes per PDF and hogs GPU VRAM.

In v0.2.0, I created TALON—a non-generative tensor pipeline using Fastcoref, MiniLM, and GLiREL zero-shot matrix classification. It runs pure CUDA tensor math to extract structured facts in ~2 seconds on my GTX 1070 without touching Ollama's VRAM allocation during ingestion.

It's 100% offline and open source under AGPL-3.0. Would love to hear your thoughts or feedback if you're building local RAG/memory setups!

hey LangChain community,

I've been working on a personal open source project called Hillock for a while now, and I just released v0.2.2.

Standard vector DB memory has two major drawbacks in production: semantic hallucinations on exact factual lookups, and slow/expensive LLM extraction during document ingestion.

Hillock replaces vector DBs with a decoupled SQLite Knowledge Graph, Hebbian Plasticity, and Hyperdimensional Computing (VSA math) for hallucination defense.

In v0.2.2, I built TALON—a non-generative tensor pipeline using Fastcoref, MiniLM, and GLiREL. It extracts structured knowledge graph facts in sub-seconds on an 8GB GTX 1070 GPU without generating a single text token.

It's 100% local, offline, and open source under AGPL-3.0. I put the GitHub link in the comments below, would love your feedback and thoughts!

Hey everyone,

A big bottleneck for long-term AI agent memory is ingestion speed. If an agent tries to extract structured Knowledge Graph facts using generative LLMs (like Llama 8B or Qwen), it takes 15+ minutes per document waiting for token-by-token JSON generation.

I've been building Hillock, an open-source local memory engine in Python. In v0.2.2, I built a non-generative tensor pipeline (TALON) that bypasses generative LLMs during ingestion:

1. Fastcoref resolves pronouns across full paragraphs first (so 'She' becomes 'Marie Curie').
2. MiniLM filters 50+ open-domain Wikidata predicates down to the top 10 for each sentence in <2ms.
3. GLiREL does single-pass zero-shot matrix classification to pull out [Subject, Predicate, Object] triples directly in GPU memory.

Because it uses pure tensor math instead of token generation, it processed 32 sentences in ~2 seconds on a GTX 1070 while using <1GB VRAM, doubling retrieval accuracy to 50%.

I've put the GitHub link in the comments below! Would love to hear your thoughts on non-generative extraction for agent memory.