これめっちゃわかりやすかったです!!!
そうかー、ontology は型で KG はその実現か〜とか、たしかにこの整理良いなと思いました!
オントロジー?ナレッジグラフ?AI時代のデータ基盤用語をざっくり理解する https://t.co/bQ9sgphkD2 #Qiita via @yushibats
RAG vs. CAG, clearly explained!
RAG is great, but it has a major problem:
every query hits the vector DB. even for static information that hasn't changed in months.
this is expensive, slow, and unnecessary.
Cache-Augmented Generation (CAG) fixes this by letting the model keep static information in its key-value (KV) memory, which is what the model builds internally for every token it reads.
in fact, you can combine RAG and CAG for the best of both worlds.
here's how it works:
RAG + CAG splits your knowledge into two layers.
↳ static data (policies, documentation) gets cached once in the model's KV memory
↳ dynamic data (recent updates, live documents) gets fetched via retrieval
you get faster inference, lower costs, and less repeated work.
the trick is being selective about what you cache.
only cache static, high-value knowledge that rarely changes. cache everything and you'll hit context limits. separating "cold" (cacheable) and "hot" (retrievable) data keeps this system reliable.
you can start today. OpenAI and Anthropic already support prompt caching in their APIs.
one thing to know before you scale it.
prompt caching matches on an exact prefix, byte for byte. your cached layer only gets reused when it sits at the very front of the context in the same order every time.
↳ reorder two cached policy documents and both turn into a miss
↳ cache document A alone and document B alone, then query both, and the second one misses because the model computed its cached state without ever seeing the first
in production this looks like a small fraction of your cached blocks serving almost all the hits. the rest just sits there.
the way out comes from how attention behaves. tokens attend mostly to their own local neighborhood, and only a few reach across document boundaries. CacheBlend recomputes those few and reuses everything else from the separately cached documents.
multi-document queries run two to four times faster, quality holds, and order stops mattering.
it ships in LMCache, which is fully open source.
repo: https://t.co/TXlaLLu04a
(don't forget to star 🌟)
below, i have quoted my article on KV cache management. it covers where prefix caching stops working and how a proper caching layer fixes it.
give it a read.
cheers! :)
Google has quietly published a method that might end the entire transformer era.
For a decade, every major AI model on earth, ChatGPT, Claude, Gemini, has been chained to the exact same architecture.
The Transformer.
It changed everything by letting models look at entire sequences at once. But it has a fatal flaw.
Its memory consumption scales quadratically. $O(L^2)$.
As context windows grow to millions of tokens, the compute cost explodes. It requires massive data centers, thousands of GPUs, and fortunes in electricity.
For years, researchers tried to replace Transformers with old-school Recurrent Neural Networks (RNNs) to get lightning-fast linear speed.
The problem? RNNs have fixed-size memory. When texts get long, they forget. They choke on complex reasoning and recall tasks.
So everyone went back to Transformers.
Until Google dropped a bombshell new paper.
They introduced Memory Caching (MC).
Instead of forcing an RNN to rely on a fixed, static memory, Google’s technique lets the model's effective memory capacity grow dynamically with the sequence length.
It acts like virtual memory for neural networks.
By caching checkpoints of hidden states and integrating smart mechanisms like sparse selective retrieval, the model dynamically looks back at what it needs, without the crushing mathematical overhead of a Transformer.
The results completely break the old rules of sequence modeling:
• Matches Transformer-level accuracy on complex in-context recall tasks.
• Completely closes the performance gap that kept RNNs sidelined for years.
• Maintains linear complexity, making long-context processing radically cheaper and faster.
We've spent years believing that massive, heavy attention mechanisms are the only way to build intelligent systems.
Google just proved you can have the infinite memory of a Transformer with the blistering speed and efficiency of an RNN.
The era of brute-forcing scale with quadratic attention is hitting a wall.
This paper is f*cking brilliant
A computer science paper establishes harness engineering as the primary determinant of AI agent reliability
The result: the ETCLOVG seven-layer architecture unifies execution sandboxes, tool protocols, context state, lifecycle graphs, observability, verifiers, and governance
The crazy part is how harness engineering boosts performance without changing the underlying model
Optimizing the execution harness alone increased SWE-bench coding benchmarks from 6.7% to 68.3%
Most developers try to fix agent failures by upgrading to larger LLMs
This framework shifts system reliability from model weights to deterministic harness architecture
Read the complete paper + article below
Bookmark it for future reference
Still the best hour on graph engineering ever recorded, Andrew Ng breaking down how to build agentic knowledge graphs from scratch:
00:00 - what agentic knowledge graphs actually are
03:05 - building a graph from scratch
13:58 - the architecture behind multi-agent systems
22:57 - building a real one with Google ADK
01:06:02 - why graphs are the future of AI agents
I've seen $500 courses that teach less.
Watch it, then take it further with my step-by-step guide on graph engineering below.