Milvus(@milvusio)

More memory doesn’t automatically make an agent better. When irrelevant history enters the context w...

Milvus (@milvusio) — Fri, 11 Sep 2026 15:38:00 GMT

More memory doesn’t automatically make an agent better.
When irrelevant history enters the context window, past experience can start competing with the information needed for the current task.

Across eight models, 𝗜𝗕𝗠 𝗥𝗲𝘀𝗲𝗮𝗿𝗰𝗵 found that the right memory “dose” varied with model capability:
• Strong models with more headroom benefited from the full guideline set.
• Weaker models performed better with a compact core and task-specific retrieval.
• Saturated models showed no measurable gain.

For gpt-oss-120b, curated retrieval improved task completion by 16.1 percentage points while using only 5% more tokens than the no-memory baseline. Injecting the full guideline set used 51% more tokens and produced a smaller gain.

A separate study observed a similar tradeoff across memory architectures. Broad retrieval helped with long-context factual QA, while excessive retrieval reduced performance on sequential decision-making by diverting attention from action-critical context.

Taken together, the findings suggest a practical approach to agent memory:
Capture broadly. Retrieve selectively. Adjust the amount of context to the model and task.

𝗠𝗲𝗺𝗦𝗲𝗮𝗿𝗰𝗵 follows this approach. Markdown remains the source of truth, while Milvus provides a rebuildable index. Retrieval combines dense search and BM25 sparse search with RRF reranking, and agents can progressively move through three levels of context:
Search results → expanded memory → original transcript

A useful memory system should provide enough context for the current task, then make deeper history available when the agent actually needs it.

If you’re building agents that need durable memory, take agithub.com/zilliztech/mem…ps://t.co/OoqhEFvafa
Resehuggingface.co/blog/ibm-resea…ps://t.carxiv.org/abs/2608.15008ps://t.co/T4zV2dN5sN

💬0🔄0❤️0👀103📊1

⚡ Powered by xgo.ing

When should you use a regular Milvus collection, and when should you use an External Collection? ...

Milvus (@milvusio) — Thu, 10 Sep 2026 15:43:00 GMT

When should you use a regular Milvus collection, and when should you use an External Collection?

𝗨𝘀𝗲 𝗮 𝗿𝗲𝗴𝘂𝗹𝗮𝗿 𝗠𝗶𝗹𝘃𝘂𝘀 𝗰𝗼𝗹𝗹𝗲𝗰𝘁𝗶𝗼𝗻 when your application continuously inserts or upserts records, deletes must become searchable through the online write path, or serving data needs to stay current. Milvus stores and manages the source records.

𝗨𝘀𝗲 𝗮𝗻 𝗘𝘅𝘁𝗲𝗿𝗻𝗮𝗹 𝗖𝗼𝗹𝗹𝗲𝗰𝘁𝗶𝗼𝗻 when the authoritative dataset already lives in Parquet, Iceberg, Lance, or Vortex. Milvus builds indexes over that data and serves it through the same search and query APIs, while freshness is controlled through an explicit Refresh.

The choice is not always either-or. A product application might keep fast-changing inventory in a regular collection and a batch-produced catalog in an External Collection.

That is the role External Collection plays in Milvus 3.0’s Vector Lakebase architecture: extending the same retrieval layer from online data to data thmilvus.io/blog/milvus-3-…

Read the full breakdown: https://t.co/VWDpFH7KLn

💬0🔄0❤️1👀174

⚡ Powered by xgo.ing

A new file lands in S3. Should production search expose it before its indexes are ready? ...

Milvus (@milvusio) — Wed, 09 Sep 2026 15:58:00 GMT

A new file lands in S3. Should production search expose it before its indexes are ready?

𝗠𝗶𝗹𝘃𝘂𝘀 𝟯.𝟬 𝗘𝘅𝘁𝗲𝗿𝗻𝗮𝗹 𝗖𝗼𝗹𝗹𝗲𝗰𝘁𝗶𝗼𝗻 avoids that partial state through an explicit Refresh boundary.

When new files, updated metadata, or new embeddings arrive in the lake, Refresh reads the external metadata and identifies which source fragments changed. Milvus can reuse the segment and index work for unchanged fragments, while processing only the new or modified ones.

During that work, queries continue using the previous published version. Once Refresh completes, the new version becomes available as a whole, so applications do not see a mixture of old and partially prepared data.

External Collection also works with Milvus Tiered Storage to reduce the serving footprint. QueryNodes can initially load lightweight metadata, then fetch fields and indexes at the chunk level as queries need them. Frequently accessed data stays cached, while colder data can remain remote or be evicted.

Together, incremental Refresh and Lazy Loading let Milvus keep lake-resident data searchable without rebuilding everything after each batch or loading the entire dataset into memory.

See homilvus.io/blog/milvus-3-…0: https://t.co/VWDpFH8iAV

💬0🔄0❤️2👀175

⚡ Powered by xgo.ing

EverOS now speaks Milvus. ⚡ v1.3.0 adds Milvus indexing for agent memory while keeping Markdown as t...

Milvus (@milvusio) — Tue, 08 Sep 2026 09:38:12 GMT

EverOS now speaks Milvus. ⚡
v1.3.0 adds Milvus indexing for agent memory while keeping Markdown as the source of truth.

Welcome to the ecosystem, @evermind! Follow @milvusio for more projects building agent memory with open-source vector search.

EverMind@evermind

EverOS 1.3.0 is out.

You can now use @milvusio or Zilliz Cloud to index your agent’s memory.

LanceDB remains the default. Markdown remains the source of truth.

Switching backends means rebuilding the index from your memory files.

Already running Milvus? EverOS now fits into your stack.

Thanks to everyone testing, reporting bugs, and contributing.

github.com/EverMind-AI/Ev…

🔗 View Quoted Tweet

💬0🔄3❤️10👀6345📊2

⚡ Powered by xgo.ing

𝗦𝘁𝗮𝗻𝗳𝗼𝗿𝗱’𝘀 𝗖𝗦𝟭𝟰𝟲𝗦 has an excellent syllabus for developers preparing to work alongsid...

Milvus (@milvusio) — Mon, 07 Sep 2026 15:37:00 GMT

𝗦𝘁𝗮𝗻𝗳𝗼𝗿𝗱’𝘀 𝗖𝗦𝟭𝟰𝟲𝗦 has an excellent syllabus for developers preparing to work alongside coding agents.

The course brings together MCP, agent skills, context engineering, agent-ready repositories, code review, security, and software factories. We especially appreciate its focus on designing workflows where humans and agents can plan, build, evaluate, and improve software together.

Milvus is honored to support The Modern Software Developer as one of its open source partners. Thank you, @mihail_eric, for building such a thoughtful and timely course.

We’d also love to welcome more developers into the Milvus community. Explore our GitHub repository and find a way github.com/milvus-io/milv…t.co/9EDa8lef6l

Follow @milvusio for project updates, technical resources, and more opportunities to get involved.

Learn more about the course and explore the themodernsoftware.devt.co/JBlVhTnCly

💬2🔄1❤️20👀1000📊8

⚡ Powered by xgo.ing

𝗚𝗣𝗧-𝟲 𝗔𝘀𝘁𝗿𝗮 𝘀𝗲𝗻𝗱𝘀 𝗮 𝘀𝗶𝗴𝗻𝗮𝗹: 𝗰𝗼𝗻𝘁𝗲𝘅𝘁 𝗰𝗼𝗺𝗽𝗮𝗰𝘁𝗶𝗼𝗻 𝗮𝗹𝗼𝗻𝗲 ...

Milvus (@milvusio) — Fri, 04 Sep 2026 15:52:00 GMT

𝗚𝗣𝗧-𝟲 𝗔𝘀𝘁𝗿𝗮 𝘀𝗲𝗻𝗱𝘀 𝗮 𝘀𝗶𝗴𝗻𝗮𝗹: 𝗰𝗼𝗻𝘁𝗲𝘅𝘁 𝗰𝗼𝗺𝗽𝗮𝗰𝘁𝗶𝗼𝗻 𝗮𝗹𝗼𝗻𝗲 𝗶𝘀 𝗻𝗼𝘁 𝗲𝗻𝗼𝘂𝗴𝗵 𝗳𝗼𝗿 𝗹𝗼𝗻𝗴-𝗿𝘂𝗻𝗻𝗶𝗻𝗴 𝗮𝗴𝗲𝗻𝘁𝘀.

The model has a 1.05M-token context window and scores 96.3% on OpenAI’s MRCR v2 8-needle test at 512K–1M context, compared with 73.8% for GPT-5.6 Sol.
One change in Codex caught my attention.

When context filled up, the usual approach was compaction: summarize the history and continue. With Astra, notes can persist across context windows, while earlier raw context remains searchable. A requirement, test result, or tool output that didn’t make it into the summary can still be retrieved later.

For Agent Memory, this creates a different data problem: 𝗸𝗲𝗲𝗽 𝗮 𝗰𝗼𝗺𝗽𝗮𝗰𝘁 𝘀𝘁𝗮𝘁𝗲, 𝗽𝗿𝗲𝘀𝗲𝗿𝘃𝗲 𝘁𝗵𝗲 𝘂𝗻𝗱𝗲𝗿𝗹𝘆𝗶𝗻𝗴 𝗲𝘃𝗶𝗱𝗲𝗻𝗰𝗲, 𝗮𝗻𝗱 𝗿𝗲𝘁𝗿𝗶𝗲𝘃𝗲 𝗯𝗲𝘁𝘄𝗲𝗲𝗻 𝘁𝗵𝗲 𝘁𝘄𝗼.

A few changes in Milvus 3.0 fit this pattern.
First, memory is not always a collection of flat chunks. A memory or trajectory has structure: summary, messages, observations, tool calls, and their relationships. StructArray is one example of how Milvus 3.0 can keep those elements under the same entity while making the individual parts searchable.

Second, searchable history needs more than vector similarity. An agent may need semantic relevance together with keywords, metadata, time, status, ordering, or aggregation. Milvus 3.0 expanded the retrieval engine across dense and sparse retrieval, filtering, ORDER BY, aggregation, and multi-vector search.

Third, memory has a storage lifecycle. A long-running agent can accumulate months or years of history. Most of it will be cold, but it still needs to remain retrievable. Milvus 3.0’s lake-native architecture and External Collections allow large histories to stay in object storage while keeping a retrieval layer over them.

So the Agent Memory problem starts to look like three problems together:
𝗵𝗼𝘄 𝗺𝗲𝗺𝗼𝗿𝘆 𝗶𝘀 𝘀𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲𝗱, 𝗵𝗼𝘄 𝗶𝘁 𝗶𝘀 𝗿𝗲𝘁𝗿𝗶𝗲𝘃𝗲𝗱, 𝗮𝗻𝗱 𝗵𝗼𝘄 𝗶𝘁 𝗶𝘀 𝘀𝘁𝗼𝗿𝗲𝗱 𝗼𝘃𝗲𝗿 𝘁𝗶𝗺𝗲.
That is the part of Astra I’m watching most closely.

💬0🔄0❤️0👀328

⚡ Powered by xgo.ing

We’re honored to support The Modern Software Developer as an OSS partner. Thank you, @mihail_eric, ...

Milvus (@milvusio) — Fri, 04 Sep 2026 07:08:23 GMT

We’re honored to support The Modern Software Developer as an OSS partner.

Thank you, @mihail_eric, for giving students the opportunity to learn AI-native engineering by contributing to production-grade open source projects. We’re excited to build with the next generation. 🚀

Mihail Eric@mihail_eric

I’m excited to finally announce the newest edition my Stanford course 𝗧𝗵𝗲 𝗠𝗼𝗱𝗲𝗿𝗻 𝗦𝗼𝗳𝘁𝘄𝗮𝗿𝗲 𝗗𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿. It has been 9 months in the making.

Last November, with the release of Claude Opus 4.5, coding agents experienced a step function improvement in capability. We all felt it. The LLMs were more powerful, could reason for longer, solve harder tasks.

This year’s iteration of my course reflects the 2026 metamorphosis of software engineering.

My core belief is simple: AI-native developers of the LLM era are going to become the most important members of any software organization. I have designed my course to train this next generation of engineers.

𝗪𝗵𝗮𝘁’𝘀 𝗱𝗶𝗳𝗳𝗲𝗿𝗲𝗻𝘁 𝘁𝗵𝗶𝘀 𝘁𝗶𝗺𝗲 𝗮𝗿𝗼𝘂𝗻𝗱

First, 85% of my Fall 2025 class material is being thrown out. The Fall 2026 syllabus reflects the core capabilities AI-native engineers must have: agent skills, advanced context engineering, MCP portals, agent-ready codebase principles, agentic code review, security, parallelizing background agents, software factories, and more.

Second, I am going to teach my students how to have software taste. Every student will be required to ship pull requests to production-grade, real-world codebases. The course is collaborating with the top open-source AI repos who will offer support and mentorship to students on how to meaningfully contribute to their projects.

This has never been done before in any university course so I am incredibly grateful to our OSS Partners: @browserbase, @HeyGen, @CopilotKit, @semgrep, @OpenHandsDev, @milvusio, @marimo_io, Pi, @crewAIInc, @warpdotdev, @vercel, @cmux, @arizeai, @UnslothAI, and @anyscalecompute.

𝗪𝗵𝗮𝘁’𝘀 𝘀𝘁𝗮𝘆𝗶𝗻𝗴 𝘁𝗵𝗲 𝘀𝗮𝗺𝗲

I’m fortunate to again have AI software engineering leaders and founders as guest speakers to share their learnings from building top coding agent products. Thank you to @leerob from @cursor_ai, @bcherny of @claudeai code, @EnoReyes of @FactoryAI, @silasalberti of @cognition, @0xine of @semgrep, Rajesh Bhatia of @Cloudflare , @amasad of @Replit, and @eladgil.

All resources will be available online. All classes will bthemodernsoftware.devic.

9/22 on Stanford campus. See you in class. 

https://t.co/wTokHyUMsz

🔗 View Quoted Tweet

💬2🔄0❤️4👀569📊2

⚡ Powered by xgo.ing

𝗠𝗶𝗹𝘃𝘂𝘀 𝟯.𝟬 𝗰𝗮𝗻 𝗻𝗼𝘄 𝗶𝗻𝗱𝗲𝘅 𝗮𝗻𝗱 𝘀𝗲𝗮𝗿𝗰𝗵 𝗱𝗮𝘁𝗮 𝘄𝗶𝘁𝗵𝗼𝘂𝘁 𝗳𝗶𝗿𝘀𝘁 ...

Milvus (@milvusio) — Thu, 03 Sep 2026 17:27:00 GMT

𝗠𝗶𝗹𝘃𝘂𝘀 𝟯.𝟬 𝗰𝗮𝗻 𝗻𝗼𝘄 𝗶𝗻𝗱𝗲𝘅 𝗮𝗻𝗱 𝘀𝗲𝗮𝗿𝗰𝗵 𝗱𝗮𝘁𝗮 𝘄𝗶𝘁𝗵𝗼𝘂𝘁 𝗳𝗶𝗿𝘀𝘁 𝗺𝗼𝘃𝗶𝗻𝗴 𝘁𝗵𝗲 𝘀𝗼𝘂𝗿𝗰𝗲 𝗿𝗼𝘄𝘀 𝗶𝗻𝘁𝗼 𝗠𝗶𝗹𝘃𝘂𝘀.

External Collection connects Milvus directly to data stored in Parquet, Apache Iceberg, Lance, Vortex, or a supported Milvus snapshot.

You define the external source, map its columns to a Milvus schema, and create the indexes your application needs. Milvus then builds and serves the retrieval layer while the original records remain in the lake.

From the application side, the experience stays familiar. Once the collection is refreshed and loaded, teams can use the same Milvus search and query APIs for:
• ANN vector search
• scalar and JSON filtering
• BM25 and full-text search
• hybrid retrieval and ranking

For large, batch-produced datasets, this provides a production retrieval path without copying the source rows into Milvus or maintaining another synchronization pipeline.

Keeping the lake as the shared data foundation is a key milvus.io/blog/milvus-3-…s 3.0’s Vector Lakebase architecture.

Read more: https://t.co/VWDpFH7KLn

💬1🔄0❤️0👀210📊1

⚡ Powered by xgo.ing

Your Spark job has finished generating embedding_v2. Now you need to add it to hundreds of millions ...

Milvus (@milvusio) — Wed, 02 Sep 2026 15:31:00 GMT

Your Spark job has finished generating embedding_v2.
Now you need to add it to hundreds of millions of existing records in Milvus—without slowing down live writes.
Sending the Parquet output back as millions of upserts forces the offline job to compete with production traffic for network, compute, and write capacity. If it fails halfway, tracking and retrying the unfinished work is another problem.

𝗕𝗮𝗰𝗸𝗳𝗶𝗹𝗹 𝗶𝗻 𝘁𝗵𝗲 𝗠𝗶𝗹𝘃𝘂𝘀 𝟯.𝟬 𝗦𝗽𝗮𝗿𝗸 𝗖𝗼𝗻𝗻𝗲𝗰𝘁𝗼𝗿 𝗸𝗲𝗲𝗽𝘀 𝘁𝗵𝗮𝘁 𝘄𝗼𝗿𝗸 𝗼𝗳𝗳𝗹𝗶𝗻𝗲:
→ A snapshot pins the schema, segment layout, and storage metadata.
→ Spark joins the Parquet output to existing rows by primary key.
→ Only the target columns are rebuilt, while row alignment is preserved.
→ Each segment becomes an independent unit for execution, validation, retry, and audit.

The result also carries its schema version, so stale output can be rejected before submission.
The goal isn’t faster upserts.

It’s a controlled path for publishing embedding_v2 without turning the producmilvus.io/blog/announcin…e migration engine.
Learn more: https://t.co/uZxGB2kxuk

💬0🔄0❤️2👀271📊1

⚡ Powered by xgo.ing

One entity doesn’t always mean one vector. A video has clips. A product has multiple images. A docu...

Milvus (@milvusio) — Tue, 01 Sep 2026 18:20:00 GMT

One entity doesn’t always mean one vector.

A video has clips. A product has multiple images. A document has passages. Compressing them into a single embedding can hide the exact details users need.

𝗠𝗶𝗹𝘃𝘂𝘀 𝟯.𝟬 𝗦𝘁𝗿𝘂𝗰𝘁𝗔𝗿𝗿𝗮𝘆 lets you store those elements inside the parent entity, with a vector and metadata for each one.

𝗛𝗼𝘄 𝘁𝗼 𝘂𝘀𝗲 𝗶𝘁:
1. Create an ARRAY<STRUCT> field for the clips, images, or passages.
2. Add vector and scalar subfields such as embedding, caption, and confidence.
3. Use element-level search to find a specific element and return its parent ID plus offset.
4. Use EmbeddingList search when both the query and entity contain multiple vectors.
5. Apply MATCH_* or element_filter to ensure vector and metadata conditions match the same element.

Useful for video search, multi-image product search, document retrieval, ColBERT, ColPali, and agent memory.
See the scmilvus.io/blog/milvus-3-…les:

https://t.co/bXZuMAsX6Q

💬0🔄0❤️2👀251📊1

⚡ Powered by xgo.ing

Upgrading an embedding model creates a deceptively large data problem. You may have billions of exi...

Milvus (@milvusio) — Fri, 28 Aug 2026 15:34:00 GMT

Upgrading an embedding model creates a deceptively large data problem.

You may have billions of existing records in Milvus, and Spark has already generated their new embeddings as Parquet files. How do you update the embeddings without rewriting every record through the online ingestion path?

𝗧𝗵𝗮𝘁’𝘀 𝘄𝗵𝗮𝘁 𝗠𝗶𝗹𝘃𝘂𝘀 𝟯.𝟬 𝗕𝗮𝗰𝗸𝗳𝗶𝗹𝗹 𝗶𝘀 𝗱𝗲𝘀𝗶𝗴𝗻𝗲𝗱 𝗳𝗼𝗿.

When teams upgrade an embedding model or recompute quality scores, labels, or ranking features, the new results often already exist as Parquet produced by Spark.

A common next step is to read those files and upsert everything back into Milvus.

That works at smaller scales. At hundreds of millions or billions of rows, it turns an offline feature pipeline into a massive online write job.

Backfill keeps the workload offline.

Instead of replaying every historical record, it uses the feature data Spark has already produced, reads only the existing data needed for the update, and writes only the target fields that changed. Unchanged fields stay untouched.

For vector fields, the connector can also validate and normalize common inputs before writing, including dimensions and sparse-vector formats.

So an embedding_v1 → embedding_v2 upgrade becomes an incremental update to the new embedding column—not a Collection-wide rewrite.

The same pattern applies when backfilling new fields, recomputing quality scores or labels, or correcting historical features at scale.

💬1🔄1❤️5👀441📊2

⚡ Powered by xgo.ing

Milvus 3.0 StructArray brings multi-vector search inside a single entity. A video can keep all its ...

Milvus (@milvusio) — Thu, 27 Aug 2026 15:52:00 GMT

Milvus 3.0 StructArray brings multi-vector search inside a single entity.

A video can keep all its clip embeddings, a document all its passage embeddings, and a product all its image embeddings—without flattening every element into a separate database row.
Each element remains attached to its parent while carrying its own vectors and scalar metadata.

This enables three retrieval patterns:
𝟭.𝗘𝗻𝘁𝗶𝘁𝘆-𝗹𝗲𝘃𝗲𝗹 𝗺𝘂𝗹𝘁𝗶-𝘃𝗲𝗰𝘁𝗼𝗿 𝘀𝗲𝗮𝗿𝗰𝗵
EmbeddingList search uses MaxSim-style scoring to compare a multi-vector query with all the vectors stored inside an entity.
𝟮.𝗘𝗹𝗲𝗺𝗲𝗻𝘁-𝗹𝗲𝘃𝗲𝗹 𝘃𝗲𝗰𝘁𝗼𝗿 𝘀𝗲𝗮𝗿𝗰𝗵
Search individual clips, passages, images, or visual patches. Each result identifies both the parent entity and the matching element’s offset.
𝟯.𝗦𝗮𝗺𝗲-𝗲𝗹𝗲𝗺𝗲𝗻𝘁 𝗳𝗶𝗹𝘁𝗲𝗿𝗶𝗻𝗴
A filter such as:
scene_type = "kitchen" AND confidence > 0.8
must match the same video clip—not two different clips within the video.

Together, these capabilities bridge element-level relevance and entity-level results: a single clip, passage, or product image can drive the match, while the application returns the full video, document, or product.

StructArray makes that local evidence searchable without losing its parent context.
𝗜𝘁 𝗮𝗹𝘀𝗼 𝘀𝘂𝗽𝗽𝗼𝗿𝘁𝘀 𝗹𝗮𝘁𝗲-𝗶𝗻𝘁𝗲𝗿𝗮𝗰𝘁𝗶𝗼𝗻 𝗿𝗲𝘁𝗿𝗶𝗲𝘃𝗮𝗹 𝗳𝗼𝗿 𝗺𝗼𝗱𝗲𝗹𝘀 𝘀𝘂𝗰𝗵 milvus.io/blog/milvus-3-…�𝗱 𝗖𝗼𝗹𝗣𝗮𝗹𝗶, where one entity is represented by many token or visual-patch vectors.

Read the technical deep dive:
https://t.co/bXZuMAsX6Q

💬0🔄3❤️4👀509📊2

⚡ Powered by xgo.ing

🚀 𝗖𝗼̂́𝗰 𝗖𝗼̂́𝗰 𝗽𝗼𝘄𝗲𝗿𝘀 𝗩𝗶𝗲𝘁𝗻𝗮𝗺’𝘀 𝗻𝗮𝘁𝗶𝗼𝗻𝗮𝗹-𝘀𝗰𝗮𝗹𝗲 𝗔𝗜 𝘀𝗲𝗮𝗿𝗰𝗵 ...

Milvus (@milvusio) — Wed, 26 Aug 2026 15:50:00 GMT

🚀 𝗖𝗼̂́𝗰 𝗖𝗼̂́𝗰 𝗽𝗼𝘄𝗲𝗿𝘀 𝗩𝗶𝗲𝘁𝗻𝗮𝗺’𝘀 𝗻𝗮𝘁𝗶𝗼𝗻𝗮𝗹-𝘀𝗰𝗮𝗹𝗲 𝗔𝗜 𝘀𝗲𝗮𝗿𝗰𝗵 𝘄𝗶𝘁𝗵 𝗠𝗶𝗹𝘃𝘂𝘀

@coccoc_official is Vietnam’s leading homegrown search engine and browser. More than 30 million people use it, generating over 600 million searches each month.

As Cốc Cốc expanded semantic retrieval across search, advertising, recommendations, targeting, and internal RAG, its existing vector libraries reached their limits. FAISS and USearch worked for smaller projects but could not distribute hundreds of millions of vectors across machines or support continuous production updates.

After validating 𝗠𝗶𝗹𝘃𝘂𝘀 with roughly 30 million query embeddings, Cốc Cốc adopted it as a self-hosted retrieval foundation for five production systems.

🚀 𝗪𝗶𝘁𝗵 𝗠𝗶𝗹𝘃𝘂𝘀, 𝗖𝗼̂́𝗰 𝗖𝗼̂́𝗰 𝗻𝗼𝘄 𝗮𝗰𝗵𝗶𝗲𝘃𝗲𝘀:
🔷 𝟳𝟬𝟬 𝗺𝗶𝗹𝗹𝗶𝗼𝗻 𝘃𝗲𝗰𝘁𝗼𝗿𝘀 in production, with capacity planned for approximately 1.5 billion
🔷 𝟭𝟵.𝟴 𝗺𝘀 𝗣𝟵𝟬 semantic-search latency at peak traffic
🔷 𝟯𝟮.𝟭 𝗺𝘀 𝗣𝟵𝟬 zilliz.com/customers/cocc…t peak traffic
🔷 𝟵milvus.io�#BuiltWithMilvust#VectorDatabase#AISearchecall with FLAT

🔗 Full story: https://t.co/J9ZvqgoZzZ

👉 Try Milvus now: https://t.co/LDXRhM00IT#BuiltWithMilvus#VectorDatabase#AISearch
---
👉 Follow Milvus, created by Zilliz, for everything related to unstructured data

💬1🔄0❤️0👀228📊1

⚡ Powered by xgo.ing

Milvus (@milvusio) — Wed, 26 Aug 2026 15:50:00 GMT

💬1🔄0❤️0👀105📊1

⚡ Powered by xgo.ing

Milvus (@milvusio) — Wed, 26 Aug 2026 15:50:00 GMT

💬0🔄0❤️0👀79

⚡ Powered by xgo.ing

We just open-sourced 𝗠𝗶𝗹𝘃𝘂𝘀 𝗳𝗼𝗿 𝗗𝗲𝗲𝗽𝗦𝗲𝗲𝗸 𝗛𝗮𝗿𝗻𝗲𝘀𝘀: DeepSeek Harness(DSH) plug...

Milvus (@milvusio) — Tue, 25 Aug 2026 15:57:00 GMT

We just open-sourced 𝗠𝗶𝗹𝘃𝘂𝘀 𝗳𝗼𝗿 𝗗𝗲𝗲𝗽𝗦𝗲𝗲𝗸 𝗛𝗮𝗿𝗻𝗲𝘀𝘀: DeepSeek Harness(DSH) plugin for Milvus

DeepSeek Harness is already at 192K+ GitHub stars. One of its core design ideas is “Everything is a Plugin”: models, tools, skills, file systems, and even the Agent Loop can all be plugged into the runtime.
𝗠𝗶𝗹𝘃𝘂𝘀 𝗻𝗼𝘄 𝗽𝗹𝘂𝗴𝘀 𝗶𝗻𝘁𝗼 𝗗𝗦𝗛 𝘁𝗼𝗼.

Install the plugin, connect Milvus or Zilliz Cloud, and a DSH agent can list collections, inspect schemas, run scalar queries, semantic search, BM25 search, and hybrid search.

Why make this a Plugin instead of only a Skill?
A Skill can tell the model:
“Inspect the schema before querying.”
“Keep the result set small.”
“Don’t delete production data.”

But these are still instructions given to the model. The model still has to understand and follow them, and that is not the same as controlling what it can execute.

The plugin controls the tool surface itself.
The first release only exposes read-only Milvus operations. There is no Delete tool. Insert, Upsert, schema changes, and admin operations aren’t exposed either.
If an operation isn’t exposed by the Plugin, the agent can’t call it through the Plugin.
So the split is pretty straightforward:
𝗦𝗸𝗶𝗹𝗹: tells the model how to work with Milvus.
𝗣𝗹𝘂𝗴𝗶𝗻: definegithub.com/zilliztech/dsh…s are available to the agent.
Repo: https://t.co/hxA0tSFDA0

💬1🔄1❤️13👀640📊3

⚡ Powered by xgo.ing

𝗪𝗲 𝗯𝗿𝗼𝘂𝗴𝗵𝘁 𝗠𝗲𝗺𝗦𝗲𝗮𝗿𝗰𝗵 𝘁𝗼 𝗗𝗲𝗲𝗽𝗦𝗲𝗲𝗸 𝗛𝗮𝗿𝗻𝗲𝘀𝘀, 𝗴𝗶𝘃𝗶𝗻𝗴 𝗶𝘁 ...

Milvus (@milvusio) — Tue, 25 Aug 2026 02:03:17 GMT

𝗪𝗲 𝗯𝗿𝗼𝘂𝗴𝗵𝘁 𝗠𝗲𝗺𝗦𝗲𝗮𝗿𝗰𝗵 𝘁𝗼 𝗗𝗲𝗲𝗽𝗦𝗲𝗲𝗸 𝗛𝗮𝗿𝗻𝗲𝘀𝘀, 𝗴𝗶𝘃𝗶𝗻𝗴 𝗶𝘁 𝗽𝗲𝗿𝘀𝗶𝘀𝘁𝗲𝗻𝘁 𝗺𝗲𝗺𝗼𝗿𝘆 𝗮𝗻𝗱 𝗮 𝗽𝗮𝘁𝗵 𝘁𝗼 𝘁𝘂𝗿𝗻 𝗿𝗲𝗽𝗲𝗮𝘁𝗲𝗱 𝗲𝘅𝗽𝗲𝗿𝗶𝗲𝗻𝗰𝗲 𝗶𝗻𝘁𝗼 𝗿𝗲𝘂𝘀𝗮𝗯𝗹𝗲 𝗦𝗸𝗶𝗹𝗹𝘀.

DeepSeek Harness is getting attention for its “everything is a plugin” architecture.
Models, tools, storage, the agent loop, scheduling, and even the UI can be replaced or recomposed.

But that raises a harder question:
If an agent can change almost any part of itself, how does it know what to improve?
It needs evidence from past work.
𝗧𝗵𝗮𝘁 𝗶𝘀 𝘄𝗵𝗮𝘁 𝗠𝗲𝗺𝗦𝗲𝗮𝗿𝗰𝗵 𝗯𝗿𝗶𝗻𝗴𝘀 𝘁𝗼 𝗗𝗲𝗲𝗽𝗦𝗲𝗲𝗸 𝗛𝗮𝗿𝗻𝗲𝘀𝘀.

𝗠𝗲𝗺𝗦𝗲𝗮𝗿𝗰𝗵 𝗽𝗿𝗲𝘀𝗲𝗿𝘃𝗲𝘀 𝘁𝗵𝗿𝗲𝗲 𝗸𝗶𝗻𝗱𝘀 𝗼𝗳 𝗺𝗲𝗺𝗼𝗿𝘆:
• What happened across previous sessions.
• What remains true about the project and the user.
• Which workflows repeat often enough to become reusable Skills.

DSH turns that third layer into an actionable experience.
Its Memory Dock surfaces Skill candidates, shows where they came from, and lets users review them before installation.

The loop is simple:
Experience → memory → repeated pattern → Skill candidate → human review → new capability

MemSearch provides the memory and learning signal.
DeepSeek Harness provides the composable runtime github.com/zilliztech/mem…omes action.
Nothingithub.com/deepseek-ai/de…ca#DeepSeekm#AIAgentso#AgentMemoryuman decides.
That is the version of agent self-evolution we find credible.

MemSearch: https://t.co/OoqhEFvI4I
DeepSeek Harness: https://t.co/vQual8kFFD#DeepSeek#AIAgents#AgentMemory

💬1🔄3❤️13👀856📊5

⚡ Powered by xgo.ing

Regex becomes an engineering problem when it has to scan millions of rows safely and predictably. ...

Milvus (@milvusio) — Fri, 21 Aug 2026 20:55:01 GMT

Regex becomes an engineering problem when it has to scan millions of rows safely and predictably.

𝗠𝗶𝗹𝘃𝘂𝘀 𝟯.𝟬 𝗮𝗱𝗱𝘀 𝘁𝗵𝗲 =~ 𝗮𝗻𝗱 !~ 𝗳𝗶𝗹𝘁𝗲𝗿𝘀 for matching or excluding structural string patterns alongside vector search, full-text search, and scalar filters.

𝗨𝗻𝗱𝗲𝗿 𝘁𝗵𝗲 𝗵𝗼𝗼𝗱, 𝗠𝗶𝗹𝘃𝘂𝘀 𝘂𝘀𝗲𝘀 𝗮 𝗹𝗮𝘆𝗲𝗿𝗲𝗱 𝗲𝘅𝗲𝗰𝘂𝘁𝗶𝗼𝗻 𝗽𝗮𝘁𝗵:

1. 𝗩𝗮𝗹𝗶𝗱𝗮𝘁𝗲 𝘄𝗶𝘁𝗵 𝗥𝗘𝟮. RE2 provides linear-time matching, and invalid patterns are rejected before the scan begins.

2. 𝗥𝗲𝘄𝗿𝗶𝘁𝗲 𝘀𝗶𝗺𝗽𝗹𝗲 𝗽𝗮𝘁𝘁𝗲𝗿𝗻𝘀. ^ERROR$ can become equality, while anchored literals can become prefix or suffix checks. The planner also evaluates cheaper predicates before regex.
3. 𝗥𝗲𝗱𝘂𝗰𝗲 𝘄𝗼𝗿𝗸 𝗼𝗻 𝗿𝗮𝘄 𝘀𝗰𝗮𝗻𝘀. On sealed segments, Milvus reuses a compiled pattern and checks required literals first, reducing the number of strings that need full RE2 verification.

4. 𝗨𝘀𝗲 𝗡𝗚𝗥𝗔𝗠 𝘄𝗵𝗲𝗻 𝗶𝘁 𝗰𝗮𝗻 𝗺𝗲𝗮𝗻𝗶𝗻𝗴𝗳𝘂𝗹𝗹𝘆 𝗿𝗲𝗱𝘂𝗰𝗲 𝗰𝗮𝗻𝗱𝗶𝗱𝗮𝘁𝗲𝘀. Milvus extracts required literals, intersects their posting lists, and runs RE2 only on the surviving strings. If it cannot safely narrow the candidate set, it falls back to raw verification.

That qualification matters: NGRAM works best for literal-rich patterns with low candidate rates. It may offer little benefit when most rows survive the first phase.

One more detail: wmilvus.io/blog/milvus-3-… missing JSON paths remain UNKNOWN. Negation does not turn missing data into a match.

Regex filtering is available in Milvus 3.0. Give it a try: https://t.co/TQE8EOUaB0

💬0🔄0❤️1👀237

⚡ Powered by xgo.ing

🌐 𝗙𝗮𝘀𝘁𝗲𝗿 𝗮𝗻𝗱 𝗠𝗼𝗿𝗲 𝗣𝗼𝘄𝗲𝗿𝗳𝘂𝗹 𝗙𝘂𝗹𝗹-𝗧𝗲𝘅𝘁 𝗦𝗲𝗮𝗿𝗰𝗵 𝘄𝗶𝘁𝗵 ...

Milvus (@milvusio) — Fri, 21 Aug 2026 15:30:00 GMT

🌐 𝗙𝗮𝘀𝘁𝗲𝗿 𝗮𝗻𝗱 𝗠𝗼𝗿𝗲 𝗣𝗼𝘄𝗲𝗿𝗳𝘂𝗹 𝗙𝘂𝗹𝗹-𝗧𝗲𝘅𝘁 𝗦𝗲𝗮𝗿𝗰𝗵 𝘄𝗶𝘁𝗵 𝗠𝗶𝗹𝘃𝘂𝘀 𝟯.𝟬 is a wrap!

Thanks to everyone who joined us live. We really appreciated your time, questions, and engagement throughout the session.

In the session, Simon Hearne, Solutions Architect at Zilliz EMEA, explored how Milvus 3.0 brings full-text and semantic search together in one engine—helping teams build faster, more flexible search experiences without maintaining separate systems.

Takeaways:
🔷 How Milvus combines native BM25 and vector search in a single query
🔷 Key Milvus 3.0 capabilities for hybrid retrieval, grouping, schema flexibility, and search efficiency
🔷 How Milvus 3.0 and Elasticsearch compare using the same dataset, embeddings, analyzers, and compute resources
🔷 How to reproduce the side-by-side comparison locally
🔷 And more...

With 𝗠𝗶𝗹𝘃𝘂𝘀 𝟯.𝟬, teams can run keyword search, semantic retrieval, filtering, grouping, and ranking in one engine—simplifying search architecture while improving performance and cost efficiency.

If you diyoutu.be/XxcA1NSQnCocan watch the replay here:
𝗥𝗲𝗰𝗼𝗿𝗱𝗶𝗻𝗴: https://t.co/VhIGjBj7bk

👉 Follow @zilliz_universe  f#Zilliz#Milvus#FullTextSearcha#HybridSearche#VectorDatabasection AI.
#Zilliz#Milvus#FullTextSearch#HybridSearch#VectorDatabase

💬0🔄1❤️3👀271📊1

⚡ Powered by xgo.ing

🔥 𝗠𝗶𝗹𝘃𝘂𝘀 𝟯.𝟬 𝗮𝗱𝗱𝘀 𝗻𝗮𝘁𝗶𝘃𝗲 𝗿𝗲𝗴𝗲𝘅 𝗳𝗶𝗹𝘁𝗲𝗿𝗶𝗻𝗴 𝘁𝗼 𝘁𝗵𝗲 𝗾𝘂𝗲𝗿𝘆 ...

Milvus (@milvusio) — Thu, 20 Aug 2026 15:30:00 GMT

🔥 𝗠𝗶𝗹𝘃𝘂𝘀 𝟯.𝟬 𝗮𝗱𝗱𝘀 𝗻𝗮𝘁𝗶𝘃𝗲 𝗿𝗲𝗴𝗲𝘅 𝗳𝗶𝗹𝘁𝗲𝗿𝗶𝗻𝗴 𝘁𝗼 𝘁𝗵𝗲 𝗾𝘂𝗲𝗿𝘆 𝗽𝗮𝘁𝗵.

Previously, the workflow was: run vector search, retrieve the top-K results, then loop through them with re.match(). The problem is that filtering happens only after the database returns the candidates, adding application logic and discarding top-K slots.

Now with Milvus 3.0, regex can run alongside vector search, full-text search, and scalar filters. 
For example: message =~ r"E[0-9]{4}:.*timeout"

𝗧𝘄𝗼 𝗼𝗽𝗲𝗿𝗮𝘁𝗼𝗿𝘀 𝗵𝗮𝗻𝗱𝗹𝗲 𝘁𝗵𝗲 𝗺𝗮𝘁𝗰𝗵𝗶𝗻𝗴:
• =~ keeps values that match patterns such as error codes, semantic versions, alternatives like ERROR|WARN, or ordered terms like checkout.*timeout.
• !~ excludes matching values.
They work with VARCHAR fields, JSON string paths, ARRAY elements, and VARCHAR subfields in StructArray expressions.

Under the hood, Milvus uses RE2, which guarantees linear-time matching and prevents catastrophic backtracking. The query planner runs cheaper predicates first, while an NGRAM milvus.io/blog/milvus-3-…ndidate set before RE2 verifies matches.

Know more: https://t.co/TQE8EOUIqy

💬0🔄4❤️5👀487📊2

⚡ Powered by xgo.ing

Top‑K tells you which chunks matched. It doesn’t tell you how concentrated those matches are. Say a...

Milvus (@milvusio) — Wed, 19 Aug 2026 15:30:00 GMT

Top‑K tells you which chunks matched. It doesn’t tell you how concentrated those matches are.

Say a RAG system retrieves 20 chunks for a question. If 18 come from the same document, that’s a very different evidence set versus 20 chunks spread across 12 documents.

A flat ranked list holds the raw data, but does not summarize result distribution for you.

𝗠𝗶𝗹𝘃𝘂𝘀 𝟯.𝟬 𝗮𝗱𝗱𝘀 𝗦𝗲𝗮𝗿𝗰𝗵 𝗔𝗴𝗴𝗿𝗲𝗴𝗮𝘁𝗶𝗼𝗻 𝘁𝗼 𝘀𝗼𝗹𝘃𝗲 𝘁𝗵𝗶𝘀.
It organizes retained ANN candidates into buckets by doc_id, tenant, product line or content type, returning bucket counts, metrics and representative hits.

For RAG pipelines, this bucketed view delivers a new retrieval signal:
 • Are candidates concentrated in a small set of sources?
 • Or spread across many different documents?

Apps can use this to decide: broaden retrieval, check more sources, or proceed with existing evidence.
Key distinction: this is a coverage signal, not a confidence score.

Search Aggregation ≠ Grouping Search
• Want fewer duplicate doc_id in your final ranked list → use Grouping Search
• Want to inspect group‑level counts & metrics → use Search Aggregation

Important limit: Search Aggregation works only over retained ANN candidates, not the full collection. Metrics depend on candidates kept dmilvus.io/blog/from-retr… the full guide: https://t.co/WCWW9oLyHw

💬0🔄2❤️5👀330📊2

⚡ Powered by xgo.ing

Milvus 3.0 Storage V3 introduces 𝗠𝗮𝗻𝗶𝗳𝗲𝘀𝘁, a versioned source of truth for datasets shared a...

Milvus (@milvusio) — Tue, 18 Aug 2026 15:30:00 GMT

Milvus 3.0 Storage V3 introduces 𝗠𝗮𝗻𝗶𝗳𝗲𝘀𝘁, a versioned source of truth for datasets shared across multiple compute paths.

In AI systems, the same data often needs to serve vector search, real-time analytics, batch processing, and model training. A common way to optimize each workload is to maintain separate copies for different engines.

That works, but it comes with a cost: more storage, more I/O, and a harder question to answer over time:
𝗪𝗵𝗶𝗰𝗵 𝗳𝗶𝗹𝗲𝘀 𝗮𝗰𝘁𝘂𝗮𝗹𝗹𝘆 𝗿𝗲𝗽𝗿𝗲𝘀𝗲𝗻𝘁 𝘁𝗵𝗲 𝗰𝘂𝗿𝗿𝗲𝗻𝘁 𝗱𝗮𝘁𝗮𝘀𝗲𝘁?

A Parquet file can tell you what it contains. It cannot tell you, by itself, which dataset version it belongs to, which deletes apply to it, which statistics and indexes are still valid, or which set of files a query should read.

As the number of workloads, file types, and update paths grows, those relationships become difficult to manage with file-level conventions alone.

Manifest gives Milvus a single place to describe dataset state: the files in a version, the schema they follow, the deletes that apply, and the statistics and indexes associated with that version.
That gives the storage layer a much cleaner contract.

Reading a Manifest tells Milvus how to interpret a specific dataset version. Writes, updates, and compaction can commit against that state, resolve conflicts, and produce a new version. Higher-level components no longer need to reconstruct those relationships independently.

For multimodal AI infrastructure, Manifest reduces unnecessary data copies and duplicated plumbing while giving every compute path a consistent view of dataset state.

💬0🔄2❤️2👀415📊1

⚡ Powered by xgo.ing

📢 𝗪𝗲𝗯𝗶𝗻𝗮𝗿 𝗿𝗲𝗺𝗶𝗻𝗱𝗲𝗿 | 𝗙𝗮𝘀𝘁𝗲𝗿 𝗮𝗻𝗱 𝗠𝗼𝗿𝗲 𝗣𝗼𝘄𝗲𝗿𝗳𝘂𝗹 𝗙𝘂𝗹𝗹-...

Milvus (@milvusio) — Mon, 17 Aug 2026 15:00:02 GMT

📢 𝗪𝗲𝗯𝗶𝗻𝗮𝗿 𝗿𝗲𝗺𝗶𝗻𝗱𝗲𝗿 | 𝗙𝗮𝘀𝘁𝗲𝗿 𝗮𝗻𝗱 𝗠𝗼𝗿𝗲 𝗣𝗼𝘄𝗲𝗿𝗳𝘂𝗹 𝗙𝘂𝗹𝗹-𝗧𝗲𝘅𝘁 𝗦𝗲𝗮𝗿𝗰𝗵 𝘄𝗶𝘁𝗵 𝗠𝗶𝗹𝘃𝘂𝘀 𝟯.𝟬, happening this Wednesday
If you’re building semantic, lexical, or hybrid search with Milvus, or comparing it with Elasticsearch for production retrieval, this webinar is for you. Simon Hearne, Solutions Architect at Zilliz, will walk through Milvus 3.0’s full-text search capabilities, live side-by-side queries, and what matters when choosing your retrieval stack.

Can’t join live? Register now and we’ll send you the recording and demo after the session.
zilliz.com/event/faster-m… 𝗔𝘂𝗴𝘂𝘀𝘁 𝟭𝟵, 𝟮𝟬𝟮𝟲

🌐 𝟭𝟭:𝟬𝟬 𝗔𝗠 𝗣𝗗𝗧
🔗 𝗥𝗲𝗴𝗶𝘀𝘁𝗲𝗿 𝗵𝗲𝗿𝗲: https://t.co/Te9HCybPCU

Zilliz@zilliz_universe

🔥 Webinar invitation: 𝗙𝗮𝘀𝘁𝗲𝗿 𝗮𝗻𝗱 𝗠𝗼𝗿𝗲 𝗣𝗼𝘄𝗲𝗿𝗳𝘂𝗹 𝗙𝘂𝗹𝗹-𝗧𝗲𝘅𝘁 𝗦𝗲𝗮𝗿𝗰𝗵 𝘄𝗶𝘁𝗵 𝗠𝗶𝗹𝘃𝘂𝘀 𝟯.𝟬
Milvus is known for vector search. With Milvus 3.0, full-text search gets a major upgrade, giving teams more options for building semantic, lexical and hybrid search with one retrieval engine.

Join Simon Hearne, Solutions Architect at Zilliz, for a technical deep dive into 𝗠𝗶𝗹𝘃𝘂𝘀 𝟯.𝟬’s full-text search capabilities. He’ll compare Milvus with Elasticsearch, walk through live side-by-side queries, and discuss how full-text and vector search can work together for hybrid retriezilliz.com/event/faster-m…�𝟵, 𝟮𝟬𝟮𝟲 | 𝟭𝟭:𝟬𝟬 𝗔𝗠 𝗣𝗗𝗧
🔗 𝗥𝗲𝗴𝗶𝘀𝘁𝗲𝗿 𝗵𝗲𝗿𝗲: https://t.co/iwQHvvLDUO

🎤 𝗪𝗵𝗮𝘁 𝘁𝗼 𝗲𝘅𝗽𝗲𝗰𝘁:
• BM25 and sparse retrieval in Milvus 3.0
• Filtering, sorting, aggregation, and faceted search
• Elasticsearch vs. Milvus capabilities and tradeoffs
• Live side-by-side queries with results and latency on screen
• Hybrid search and ranking with methods such as RRF
• Production examples and more  

Bring your search patterns and architecture questions, and join us li#MilvusF#FullTextSearchn#VectorDatabasetor database and vector lakebase updates built for production AI.
#Milvus#FullTextSearch#VectorDatabase

🔗 View Quoted Tweet

💬0🔄1❤️2👀433📊1

⚡ Powered by xgo.ing

Vector search retrieves a relevant candidate set. A product-search page still needs a structured res...

Milvus (@milvusio) — Fri, 14 Aug 2026 15:30:00 GMT

Vector search retrieves a relevant candidate set. A product-search page still needs a structured result: brand filters, price ranges, representative products, and a reliable order across pages.

Before Milvus 3.0, applications commonly built that second step themselves: fetch rows from Milvus, group them, calculate metrics, then sort them.

That creates two problems.
• The application has to pull a large list of products just to calculate a few small things, such as how many results each brand has or the price range. Most of that data is never shown to the user.
• Sorting after pagination only sorts one page at a time. Page 1 might start at $45, while a $30 product is still sitting on Page 2. And sorting cannot bring back a relevant product that was not included in the original search results.

𝗠𝗶𝗹𝘃𝘂𝘀 𝟯.𝟬 𝗯𝗿𝗶𝗻𝗴𝘀 𝘁𝗵𝗶𝘀 𝘄𝗼𝗿𝗸 𝗶𝗻𝘁𝗼 𝘁𝗵𝗲 𝗿𝗲𝘁𝗿𝗶𝗲𝘃𝗮𝗹 𝗲𝗻𝗴𝗶𝗻𝗲:
• Query Aggregation gives exact stats over filtered, visible rows.
• Search Aggregation returns buckets, metrics, and representative candidates.
• Server-side ORDER BY controls sorting and pagination.

Use query ORDER BY when scalar order defines the result. Use search ordering when ANN establishes the candidate set and scalarmilvus.io/blog/from-retr…ntation.
Full guide:
https://t.co/WCWW9oM6x4

💬0🔄0❤️1👀208

⚡ Powered by xgo.ing

A customer searches by image and gets a list of similar products. But the page also needs brand fil...

Milvus (@milvusio) — Thu, 13 Aug 2026 15:35:00 GMT

A customer searches by image and gets a list of similar products.

But the page also needs brand filters, price ranges, representative items, and a sensible order across pages.

Before Milvus 3.0, the application had to build that second layer itself: retrieve candidates, group them by brand, calculate counts and averages, select representative items, and sort the results.

That means more data leaving the database, more post-processing code, and more room for errors. For example, sorting each fetched page by price does not produce a globally price-sorted result.

𝗠𝗶𝗹𝘃𝘂𝘀 𝟯.𝟬 𝗺𝗼𝘃𝗲𝘀 𝘁𝗵𝗶𝘀 𝘄𝗼𝗿𝗸 𝗶𝗻𝘁𝗼 𝘁𝗵𝗲 𝗿𝗲𝘁𝗿𝗶𝗲𝘃𝗮𝗹 𝗲𝗻𝗴𝗶𝗻𝗲:
• 𝗤𝘂𝗲𝗿𝘆 𝗔𝗴𝗴𝗿𝗲𝗴𝗮𝘁𝗶𝗼𝗻 returns exact grouped statistics over filtered, visible rows.
• 𝗦𝗲𝗮𝗿𝗰𝗵 𝗔𝗴𝗴𝗿𝗲𝗴𝗮𝘁𝗶𝗼𝗻 returns buckets, metrics, and representative hits over ANN candidates.
• 𝗦𝗲𝗿𝘃𝗲𝗿-𝘀𝗶𝗱𝗲 𝗢𝗥𝗗𝗘𝗥 𝗕𝗬 sorts results before they reach the application.

Now a product-search experience can receive structured results directly, rather thanmilvus.io/blog/from-retr…hat needs to be rebuilt after retrieval.

Full technical walkthrough:
https://t.co/WCWW9oLyHw

💬0🔄0❤️1👀247

⚡ Powered by xgo.ing

A Milvus Snapshot is a named, read-only, point-in-time version of a collection. It records referenc...

Milvus (@milvusio) — Wed, 12 Aug 2026 16:42:29 GMT

A Milvus Snapshot is a named, read-only, point-in-time version of a collection.

It records references to the data and index files already in object storage, rather than duplicating the dataset.

That makes it useful before a model upgrade or data backfill.

Here’s the basic workflow:
• 𝗦𝗲𝘁 𝘁𝗵𝗲 𝗯𝗼𝘂𝗻𝗱𝗮𝗿𝘆
If recent writes must be included, run Flush first. Growing segments are not included in a snapshot.
• 𝗖𝗿𝗲𝗮𝘁𝗲 𝘁𝗵𝗲 𝘀𝗻𝗮𝗽𝘀𝗵𝗼𝘁
Give it a meaningful name, such as before_model_v2, so its retention purpose is clear.
• 𝗨𝘀𝗲 𝗶𝘁
Restore into a new collection to validate a rollback, or read it through Spark / External Collection as fixed input.

Then clean up. Snapshot-referenced files cannot be garbage-collected, so drop snapshots when they no longer eamilvus.io/blog/milvus-sn…walkthrough: https://t.co/sIBHa6dwAR

💬0🔄0❤️0👀233

⚡ Powered by xgo.ing

Before an embedding model upgrade or data backfill, you need a recovery point. But a full backup ...

Milvus (@milvusio) — Tue, 11 Aug 2026 15:30:00 GMT

Before an embedding model upgrade or data backfill, you need a recovery point.  

But a full backup is too heavy to take before every re-embedding or data backfill.

𝗠𝗶𝗹𝘃𝘂𝘀 𝗦𝗻𝗮𝗽𝘀𝗵𝗼𝘁𝘀 create a point-in-time, read-only view of a collection by recording existing data, index, and metadata files—without copying vector data.

If a change goes wrong, restore the snapshot into a new collection: no full re-import, no index rebuild, and no overwrite of production.

A recovery point you can afford to take before every risky change.

Knomilvus.io/blog/milvus-sn…t.co/sIBHa6dwAR

💬0🔄0❤️2👀225

⚡ Powered by xgo.ing

Milvus 3.0 further expands what its retrieval engine can handle, with stronger support for in-engine...

Milvus (@milvusio) — Mon, 10 Aug 2026 15:31:00 GMT

Milvus 3.0 further expands what its retrieval engine can handle, with stronger support for in-engine ranking, aggregation, multi-vector search, and sparse retrieval.

In production, vector search rarely ends with top-k ANN results. Beyond retrieving candidates, applications often need to sort by freshness, price, rating, inventory, or timestamp; group results by category; return facets; and work with entities that contain many vectors, such as document chunks, video frames, product images, or ColBERT token vectors.

Milvus has long supported dense and sparse vector search, hybrid retrieval, and filtering. Milvus 3.0 builds on that foundation by bringing more ranking, grouping, and result-processing work closer to the retrieval path.

ORDER BY sorts filtered query results by scalar fields and can also sort ANN candidates within Milvus. Query-side aggregation supports count, sum, avg, min, and max, grouped by scalar fields. Search aggregation adds faceted search over retrieved hits, returning bucket counts, aggregate statistics, and top-N sample hits per bucket. Since it operates on ANN results, facet counts are approximate; use query-side aggregation when exact counts matter.

StructArray lets a single entity contain a variable-length list of structured elements and vectors while remaining one row. It fits workloads such as document chunks, video frames, product images, and late-interaction models like ColBERT.

Sparse retrieval is also enhanced with compressed BM25 indexes and SINDI, an algorithm designed for learned sparse embeddings such as SPLADE.

For retrieval teams, the practical benefit is less over-fetching and less custom application-side logic for ranking, grouping, faceting, multi-vector scoring, and sparse search.

More in the Milvus 3.0 launch blog: milvus.io/blog/announcin…

💬0🔄1❤️10👀470📊2

⚡ Powered by xgo.ing

When an AI Agent gives a bad answer, the model is not always the first place we should look. When a...

Milvus (@milvusio) — Fri, 07 Aug 2026 15:30:00 GMT

When an AI Agent gives a bad answer, the model is not always the first place we should look.

When an answer is weak, teams often look at the prompt, model, or agent logic first. But many issues start earlier: the system retrieved the wrong context, missed the right one, or filtered it out before the LLM saw it.

That is why Simon Hearne's talk on visualizing vector search is worth watching. It makes the retrieval layer feel less like a black box.

In SQL, EXPLAIN shows the plan, index, and why a query behaves a certain way.

Vector search is messier. Results are shaped by embeddings, index choice, quantization, metadata filters, and the latency/recall tradeoffs teams make.

Simon walks through examples that come up quickly in production:
• Brute-force search is easy to trust, until the dataset gets large.
• IVF, HNSW, and DiskANN each make different tradeoffs.
• Quantization can help with speed and storage, but recall still needs checking.
• Filters can remove the paths to the best matches.
For teams building RAG or agents, the lesson is simple: debug retrieval directly.

Track recall@k. Look at score distributions. Watch filter hit rates. Treat index and embedding changes as quality changes.

This is the engineering work Milvus is built around: a production retrieval layer teams can tune, scale, and reason about.
Watch Simon's visual explanation here: youtube.com/watch?v=kY-il0…

💬1🔄0❤️3👀266📊2

⚡ Powered by xgo.ing

𝗠𝗶𝗹𝘃𝘂𝘀 𝟯.𝟬 𝗰𝗵𝗮𝗻𝗴𝗲𝘀 𝘀𝗼𝗺𝗲 𝗼𝗳 𝘁𝗵𝗲 𝗮𝘀𝘀𝘂𝗺𝗽𝘁𝗶𝗼𝗻𝘀 𝗯𝗲𝗵𝗶𝗻𝗱 ...

Milvus (@milvusio) — Fri, 07 Aug 2026 05:52:09 GMT

𝗠𝗶𝗹𝘃𝘂𝘀 𝟯.𝟬 𝗰𝗵𝗮𝗻𝗴𝗲𝘀 𝘀𝗼𝗺𝗲 𝗼𝗳 𝘁𝗵𝗲 𝗮𝘀𝘀𝘂𝗺𝗽𝘁𝗶𝗼𝗻𝘀 𝗯𝗲𝗵𝗶𝗻𝗱 𝗿𝗲𝘁𝗿𝗶𝗲𝘃𝗮𝗹 𝗮𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲.

With lake-native External Collections and richer retrieval capabilities like grouping, faceting, sorting, filtering, and aggregation, Milvus can work with data where it already lives — while giving applications more precise control over retrieval than semantic similarity alone.

That opens up some practical architecture questions:
-> Where should embeddings live?
-> How should you tune hybrid search for your workload?
-> How do filters affect the trade-off between recall and latency?
-> And when an answer looks plausible but the retrieved context is wrong, where do you start debugging?

If you’re working through questions like these, bring them to 𝗠𝗶𝗹𝘃𝘂𝘀 𝗢𝗳𝗳𝗶𝗰𝗲 𝗛𝗼𝘂𝗿𝘀.

Book a 20-minute 1:1 session with Milvus experts to talk through schema design, performance, scaling, troubleshomeetings.hubspot.com/chloe-williams…r Milvus 3.0 architecture decisions.

🔥 Book a session: https://t.co/CCeh01Cjko

💬0🔄1❤️2👀270📊1

⚡ Powered by xgo.ing

𝗠𝗶𝗹𝘃𝘂𝘀 𝟯.𝟬 𝗺𝗮𝗸𝗲𝘀 𝗿𝗲𝘁𝗿𝗶𝗲𝘃𝗮𝗹 𝗮𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲 𝗺𝗼𝗿𝗲 ...

Milvus (@milvusio) — Thu, 06 Aug 2026 15:30:00 GMT

𝗠𝗶𝗹𝘃𝘂𝘀 𝟯.𝟬 𝗺𝗮𝗸𝗲𝘀 𝗿𝗲𝘁𝗿𝗶𝗲𝘃𝗮𝗹 𝗮𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲 𝗺𝗼𝗿𝗲 𝗶𝗻𝘁𝗲𝗿𝗲𝘀𝘁𝗶𝗻𝗴.

Vectors no longer live in isolation. With lake-native External Collection and structured queries like grouping, faceting, sorting, and aggregation, Milvus can sit closer to the data systems teams already use.

That raises real questions:

Where should embeddings live?
How do you tune hybrid search?
How do you balance recall, latency, filters, and cost?
How do you debug retrieval when answers look plausible but context is wrong?

𝗕𝗿𝗶𝗻𝗴 𝘁𝗵𝗼𝘀𝗲 𝗾𝘂𝗲𝘀𝘁𝗶𝗼𝗻𝘀 𝘁𝗼 𝗠𝗶𝗹𝘃𝘂𝘀 𝗢𝗳𝗳𝗶𝗰𝗲 𝗛𝗼𝘂𝗿𝘀.

Book a 20-minute 1:1 session with Milvus experts for help on schema design, performmeetings.hubspot.com/milvus-office-…hooting, or Milvus 3.0 architecture decisions.

🙋🏻♀️ Join here: https://t.co/FwBKy9bIe1

💬0🔄1❤️3👀200📊1

⚡ Powered by xgo.ing

𝗠𝗶𝗹𝘃𝘂𝘀 𝟯.𝟬 𝗶𝗻𝘁𝗿𝗼𝗱𝘂𝗰𝗲𝘀 𝗼𝗻𝗹𝗶𝗻𝗲 𝘀𝗰𝗵𝗲𝗺𝗮 𝗲𝘃𝗼𝗹𝘂𝘁𝗶𝗼𝗻 𝗮𝗻𝗱 ...

Milvus (@milvusio) — Wed, 05 Aug 2026 15:15:00 GMT

𝗠𝗶𝗹𝘃𝘂𝘀 𝟯.𝟬 𝗶𝗻𝘁𝗿𝗼𝗱𝘂𝗰𝗲𝘀 𝗼𝗻𝗹𝗶𝗻𝗲 𝘀𝗰𝗵𝗲𝗺𝗮 𝗲𝘃𝗼𝗹𝘂𝘁𝗶𝗼𝗻 𝗮𝗻𝗱 𝗯𝗮𝗰𝗸𝗳𝗶𝗹𝗹, 𝗮𝗹𝗹𝗼𝘄𝗶𝗻𝗴 𝘁𝗲𝗮𝗺𝘀 𝘁𝗼 𝗰𝗵𝗮𝗻𝗴𝗲 𝗮 𝗰𝗼𝗹𝗹𝗲𝗰𝘁𝗶𝗼𝗻’𝘀 𝗱𝗮𝘁𝗮 𝗺𝗼𝗱𝗲𝗹 𝘄𝗵𝗶𝗹𝗲 𝗶𝘁 𝗰𝗼𝗻𝘁𝗶𝗻𝘂𝗲𝘀 𝘀𝗲𝗿𝘃𝗶𝗻𝗴 𝘁𝗿𝗮𝗳𝗳𝗶𝗰.

In production retrieval systems, schemas rarely remain static. As retrieval requirements evolve, teams frequently need to add new embedding models, sparse vectors, labels, metadata fields, text columns, and retention policies. Before Milvus 3.0, these data model changes often came with high operational costs, requiring disruptive collection rebuilds or carefully scheduled migration windows to avoid service impact.

To resolve this pain point, Milvus 3.0 enables teams to add, populate, and drop fields without taking the collection offline. Adding a field creates a new nullable column without rewriting existing data. Dropping a deprecated or experimental field updates the collection metadata at runtime. Both operations simply update the collection manifest instead of forcing a full data rewrite, significantly reducing operational overhead.

While online schema changes support structural updates, backfill complements the capability by completing the full schema-evolution workflow and populating newly added fields with valid data.

Milvus 3.0 supports inner backfill for values derived from data already stored in the collection. For example, Milvus can generate BM25 sparse vectors directly from a text field, removing the need for a separate client-side encoder in dense-and-sparse hybrid retrieval pipelines.

In addition to in-engine backfill, external backfill is on the roadmap for scenarios where new column values need to be computed outside Milvus. The workflow is straightforward: take a snapshot, run Spark against the stable view, compute the new column, write the values back, and let Milvus update the relevant indexes incrementally.

Combined together, online schema evolution and backfill enable retrieval pipelines to iterate flexibly. Teams can continuously adjust data models to fit evolving busimilvus.io/blog/announcin…uilding the entire collection every time schema updates occur.
More in the Milvus 3.0 launch blog: https://t.co/hq4qqZASuX

💬0🔄0❤️1👀304📊1

⚡ Powered by xgo.ing

𝗠𝗶𝗹𝘃𝘂𝘀 𝟯.𝟬: 𝗦𝘁𝗮𝗯𝗹𝗲 𝗦𝗻𝗮𝗽𝘀𝗵𝗼𝘁𝘀 𝗮𝗻𝗱 𝗕𝗮𝘁𝗰𝗵 𝗣𝗿𝗼𝗰𝗲𝘀𝘀𝗶𝗻𝗴 𝗳𝗼𝗿 ...

Milvus (@milvusio) — Tue, 04 Aug 2026 15:30:00 GMT

𝗠𝗶𝗹𝘃𝘂𝘀 𝟯.𝟬: 𝗦𝘁𝗮𝗯𝗹𝗲 𝗦𝗻𝗮𝗽𝘀𝗵𝗼𝘁𝘀 𝗮𝗻𝗱 𝗕𝗮𝘁𝗰𝗵 𝗣𝗿𝗼𝗰𝗲𝘀𝘀𝗶𝗻𝗴 𝗳𝗼𝗿 𝗘𝘃𝗼𝗹𝘃𝗶𝗻𝗴 𝗔𝗜 𝗗𝗮𝘁𝗮

Milvus 3.0 introduces Collection Snapshot and a Spark connector to help teams create consistent views of changing AI data, run distributed batch processing, and write updated results back into Milvus.

Traditional business data mainly records facts such as orders, product details, or device states. In AI systems, however, more data is generated by models. Embeddings, quality scores, classification labels, and reranking features all depend on specific models and processing logic. When models or business rules change, the same source data often needs to be recomputed, even while the production collection continues serving queries and accepting writes.

𝗖𝗼𝗹𝗹𝗲𝗰𝘁𝗶𝗼𝗻 𝗦𝗻𝗮𝗽𝘀𝗵𝗼𝘁 provides a stable input for these workflows. It creates a read-only view of a collection at a specific point in time by referencing existing data files, index files, and metadata, without copying the full dataset. Teams can use snapshots for model migration, embedding regeneration, schema changes, backfills, evaluation, deduplication, and isolated testing.

Snapshots can also serve as logical recovery points, but they do not replace backups. A snapshot may still share the same underlying storage as production, making it better suited to short-term isolation and recovery. Independent backups remain necessary for long-term retention and disaster recovery.

The Spark connector, built on Spark DataSource V2, allows Spark, Databricks, and Amazon EMR to read from and write to Milvus directly. Teams can process snapshot data with distributed jobs, then write new embeddings, labels, scores, or curated results back into Milvus.

Snapshots provide a stable data view. Spark provides distributed compute. Milvus 3.0 connects them into one workfmilvus.io/blog/announcin…ata improvement.
More in the Milvus 3.0 launch blog: https://t.co/hq4qqZASuX

💬0🔄1❤️2👀301📊1

⚡ Powered by xgo.ing

Milvus 3.0 resolves the fundamental AI workload conflict between continuously changing production da...

Milvus (@milvusio) — Mon, 03 Aug 2026 15:30:00 GMT

Milvus 3.0 resolves the fundamental AI workload conflict between continuously changing production data and stable offline computation by introducing low-cost, point-in-time, read-only collection snapshots.

In AI systems, data states shift constantly: models are updated, embeddings are regenerated, and schemas evolve, while online collections must continuously serve queries and ingest new writes. Offline batch jobs, however, require fixed, reproducible data views to generate consistent results—a gap snapshots are designed to fill.

𝗦𝗻𝗮𝗽𝘀𝗵𝗼𝘁𝘀 achieve low overhead by referencing existing data, index, and metadata files instead of duplicating full datasets. This enables lightweight checkpoint creation before risky operations including model swapping, re-embedding, and schema migration.

While the primary production collection keeps changing, immutable snapshot views support a wide range of isolated batch workflows, such as A/B evaluation, deduplication, backfill validation, and offline testing.

Snapshots also accelerate data recovery and cloning. Milvus reuses existing data and index files via object storage server-side copy, eliminating expensive full data reimports and index rebuilds.

This capability is critical for AI pipelines, because embeddings and derived features are version-dependent outputs rather than permanent source-data attributes. Snapshots provide stable, low-cost checkpoints for validating iterations and rolling back faulty releases without heavy backup overhead.

Notably, snapshots do not replace backups. Snapshots rely on live collection resources and serve short-term logical operations: version rollback, cloning, and stable view isolation. Backups create independent, durable copies for long-term retention and disaster recovery.

In summary, snapshots manage frequent data changes for agile AI iteration, while backups protect against permanent data loss.

Knmilvus.io/blog/milvus-sn…svDWFw3lp

💬0🔄2❤️4👀239📊1

⚡ Powered by xgo.ing

🎉 𝗠𝗶𝗹𝘃𝘂𝘀 𝟯.𝟬 𝗶𝘀 𝗻𝗼𝘄 𝗮𝘃𝗮𝗶𝗹𝗮𝗯𝗹𝗲, 𝗮𝗻𝗱 𝗶𝘁’𝘀 𝗮 𝗺𝗮𝗷𝗼𝗿 𝘀𝘁𝗲𝗽 ...

Milvus (@milvusio) — Fri, 31 Jul 2026 15:00:02 GMT

🎉 𝗠𝗶𝗹𝘃𝘂𝘀 𝟯.𝟬 𝗶𝘀 𝗻𝗼𝘄 𝗮𝘃𝗮𝗶𝗹𝗮𝗯𝗹𝗲, 𝗮𝗻𝗱 𝗶𝘁’𝘀 𝗮 𝗺𝗮𝗷𝗼𝗿 𝘀𝘁𝗲𝗽 𝘁𝗼𝘄𝗮𝗿𝗱 𝗹𝗮𝗸𝗲-𝗻𝗮𝘁𝗶𝘃𝗲 𝘃𝗲𝗰𝘁𝗼𝗿 𝘀𝗲𝗮𝗿𝗰𝗵.

🔥 Key highlights:
• External Collections let teams build retrieval directly where their data already lives: in object storage, open data formats like Parquet and Vortex, and open table formats like Lance and Iceberg.
• Loon Storage v3 improves point reads for lake-native retrieval on S3-style object storage.
• Snapshots, Spark DataSource V2, and live schema changes bring stable collection views into batch workflows, recovery, backfill, and schema evolution.
• ORDER BY, aggregation, and faceted search move more result processing into the retrieval engine.
• StructArray and SINDI strengthen multi-vector, sparse, and hybrid retrieval workloads.

For builders working on RAG, agents, multimodal search, and AI data pipelines, Milvus 3.0 reduces duplicate data movement and pushes more retrieval logic into the engine itself.

It is a big step toward a cleaner architecture: lake-native storage, offline data improvement, online serving, and retrieval-time processigithub.com/milvus-io/milv…one open-source vectormilvus.io/blog/announcin…https://t.co/3ckzkUVicH 
📖 Full launch blog: https://t.co/hq4qqZASuX

💬1🔄0❤️3👀229📊2

⚡ Powered by xgo.ing

𝗠𝗶𝗹𝘃𝘂𝘀 𝟯.𝟬 𝗶𝗻𝘁𝗿𝗼𝗱𝘂𝗰𝗲𝘀 𝗦𝘁𝗼𝗿𝗮𝗴𝗲 𝘃𝟯, 𝗮𝗹𝘀𝗼 𝗸𝗻𝗼𝘄𝗻 𝗮𝘀 𝗟𝗼𝗼𝗻, 𝗮 ...

Milvus (@milvusio) — Thu, 30 Jul 2026 15:30:00 GMT

𝗠𝗶𝗹𝘃𝘂𝘀 𝟯.𝟬 𝗶𝗻𝘁𝗿𝗼𝗱𝘂𝗰𝗲𝘀 𝗦𝘁𝗼𝗿𝗮𝗴𝗲 𝘃𝟯, 𝗮𝗹𝘀𝗼 𝗸𝗻𝗼𝘄𝗻 𝗮𝘀  𝗟𝗼𝗼𝗻, 𝗮 𝘀𝘁𝗼𝗿𝗮𝗴𝗲 𝗲𝗻𝗴𝗶𝗻𝗲 𝗯𝘂𝗶𝗹𝘁 𝗳𝗼𝗿 𝘀𝗲𝗿𝘃𝗶𝗻𝗴-𝘀𝘁𝘆𝗹𝗲 𝗮𝗰𝗰𝗲𝘀𝘀 𝗼𝗻 𝗼𝗯𝗷𝗲𝗰𝘁 𝘀𝘁𝗼𝗿𝗮𝗴𝗲.

Loon handles a specific problem: after ANN search returns candidate IDs, Milvus still has to fetch the fields for those rows.

On object storage, that fetch can become expensive. Analytical file formats are optimized for scans, not serving-style point reads. A query may only need a few vectors or metadata fields, but the layout can force the engine to read much more.

𝗟𝗼𝗼𝗻 𝗿𝗲𝗱𝘂𝗰𝗲𝘀 𝘁𝗵𝗶𝘀 𝗿𝗲𝗮𝗱 𝗮𝗺𝗽𝗹𝗶𝗳𝗶𝗰𝗮𝘁𝗶𝗼𝗻 𝗯𝘆 𝗼𝗿𝗴𝗮𝗻𝗶𝘇𝗶𝗻𝗴 𝗱𝗮𝘁𝗮 𝗶𝗻𝘁𝗼 𝗖𝗼𝗹𝘂𝗺𝗻𝗚𝗿𝗼𝘂𝗽𝘀 𝘄𝗶𝘁𝗵 𝗮𝗹𝗶𝗴𝗻𝗲𝗱 𝗿𝗼𝘄 𝗜𝗗𝘀. Different fields can then use layouts that match how they are actually accessed:
• Scalar fields can be laid out for filtering.
• Vectors and point-read-heavy fields can use layouts for narrow lookups.
• Vector and inverted indexes stay separate from the file format.
• Each dataset version is tracked by an immutable manifest.

In one internal benchmark, point-read Imilvus.io/blog/why-we-bu….4 MB with Parquet to 0.07 MB with Vortex and Loon. This matters because zero-copy search still needs a storage path built for retrieval workloads.

Blog: https://t.co/d4Fgu31EfN

💬0🔄1❤️6👀278📊2

⚡ Powered by xgo.ing

Milvus (@milvusio) — Wed, 29 Jul 2026 14:06:18 GMT

💬0🔄0❤️1👀106

⚡ Powered by xgo.ing

Milvus (@milvusio) — Wed, 29 Jul 2026 14:06:17 GMT

💬1🔄0❤️1👀122📊1

⚡ Powered by xgo.ing

🎉 We're so excited to announce that Milvus 3.0 is available today! This is the biggest architectura...

Milvus (@milvusio) — Wed, 29 Jul 2026 14:06:16 GMT

🎉 We're so excited to announce that Milvus 3.0 is available today! This is the biggest architectural release in the project's history, with two big shifts.

🌊 𝗦𝗛𝗜𝗙𝗧 𝟭 — 𝗟𝗮𝗸𝗲-𝗻𝗮𝘁𝗶𝘃𝗲 𝗶𝗻𝗳𝗿𝗮𝘀𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲
The problem: your vectors already live in the lake, but your search engine needs its own copy. So you build an ETL pipeline — and then maintain it forever. With Milvus 3.0, you get:

1. External Collections → index and serve data that stays in Parquet, Lance, Iceberg, or Vortex. No second copy, no sync job.

2. Loon (Storage v3) → a columnar engine built for the point reads that follow an ANN search. I/O per read went from 9.4 MB to 0.07 MB in our benchmarks.

3. Snapshots + Spark + live schema changes → dedupe, re-embed, and evaluate your data while the live collection keeps serving.

⚡ 𝗦𝗛𝗜𝗙𝗧 𝟮 — 𝗔 𝗺𝗼𝗿𝗲 𝗽𝗼𝘄𝗲𝗿𝗳𝘂𝗹 𝗿𝗲𝘁𝗿𝗶𝗲𝘃𝗮𝗹 𝗲𝗻𝗴𝗶𝗻𝗲
The problem: too much of your retrieval pipeline lives in application code. You over-fetch candidates, then sort, count, and reassemble them yourself. With Milvus 3.0, you get:

1. Server-side ORDER BY, aggregation, and faceted search → sort by price or freshness, count by category, all inside the engine.

2. StructArray → one row per document, many vectors inside. ColBERT and ColPali finally have a native home.

3. SINDI + BM25 compression → a sparse index ~3× smaller, with up to ~10× the QPS on learned sparse embeddings.

Put together: one system, one copy of your data, and a lot less glue code.

That matters most if you're building: 🤖 AI agents whose data changes constantly 🔍 Multimodal retrieval with late-interaction models 🔒 Governed systems where the data has to stay where it is 📚 RAG and knowledge bases over long documents 🛍️ Search that mixes relevance with price, rating, or inventory

🙏 Huge thanks to the Milvus community — you filed the issues, tested the release candidates, and told us what was actually painful. This releagithub.com/milvus-io/milv…wipe through for the milvus.io/blog/announcin…r#Milvust#VectorDatabaseU#AIInfrastructurec#RAGo#OpenSourcet.co/hq4qqZASuX
#Milvus#VectorDatabase#AIInfrastructure#RAG#OpenSource

💬1🔄3❤️12👀576📊4

⚡ Powered by xgo.ing

⭐ 𝗠𝗶𝗹𝘃𝘂𝘀 𝟯.𝟬 𝗶𝗻𝘁𝗿𝗼𝗱𝘂𝗰𝗲𝘀 𝗘𝘅𝘁𝗲𝗿𝗻𝗮𝗹 𝗖𝗼𝗹𝗹𝗲𝗰𝘁𝗶𝗼𝗻𝘀, 𝗮 𝘄𝗮𝘆 𝘁𝗼 ...

Milvus (@milvusio) — Tue, 28 Jul 2026 15:30:00 GMT

⭐ 𝗠𝗶𝗹𝘃𝘂𝘀 𝟯.𝟬 𝗶𝗻𝘁𝗿𝗼𝗱𝘂𝗰𝗲𝘀 𝗘𝘅𝘁𝗲𝗿𝗻𝗮𝗹 𝗖𝗼𝗹𝗹𝗲𝗰𝘁𝗶𝗼𝗻𝘀, 𝗮 𝘄𝗮𝘆 𝘁𝗼 𝗺𝗮𝗸𝗲 𝗹𝗮𝗸𝗲-𝗿𝗲𝘀𝗶𝗱𝗲𝗻𝘁 𝘃𝗲𝗰𝘁𝗼𝗿 𝗱𝗮𝘁𝗮 𝘀𝗲𝗮𝗿𝗰𝗵𝗮𝗯𝗹𝗲 𝘄𝗶𝘁𝗵𝗼𝘂𝘁 𝗰𝗼𝗽𝘆𝗶𝗻𝗴 𝗶𝘁 𝗶𝗻𝘁𝗼 𝗮 𝘀𝗲𝗿𝘃𝗶𝗻𝗴 𝗱𝗮𝘁𝗮𝗯𝗮𝘀𝗲.

Many teams already have embeddings and metadata in object storage: Parquet files in S3, Lance datasets, Iceberg tables, or other lakehouse formats.

Before Milvus 3.0, there were usually two ways to make that data searchable.
𝗢𝗽𝘁𝗶𝗼𝗻 𝗼𝗻𝗲: 𝗰𝗼𝗽𝘆 𝗶𝘁 𝗶𝗻𝘁𝗼 𝗮 𝘃𝗲𝗰𝘁𝗼𝗿 𝗱𝗮𝘁𝗮𝗯𝗮𝘀𝗲. You get low-latency ANN search, but now you have a second copy and an ETL pipeline to keep in sync.
𝗢𝗽𝘁𝗶𝗼𝗻 𝘁𝘄𝗼: 𝗾𝘂𝗲𝗿𝘆 𝘁𝗵𝗲 𝗹𝗮𝗸𝗲 𝗱𝗶𝗿𝗲𝗰𝘁𝗹𝘆. You avoid duplication, but without ANN indexes, vector search turns into a brute-force scan.

𝗘𝘅𝘁𝗲𝗿𝗻𝗮𝗹 𝗖𝗼𝗹𝗹𝗲𝗰𝘁𝗶𝗼𝗻𝘀 𝗶𝗻𝘁𝗿𝗼𝗱𝘂𝗰𝗲 𝗮 𝘁𝗵𝗶𝗿𝗱 𝗽𝗮𝘁𝗵.
You keep the data where it is, map external fields into a Milvus schema, and use the same Milvus search and query APIs. Milvus builds vector, BM25 inverted, JSON, and scalar indexes over the lake-resident data. The source files do not move.

For teams where the lake owns permissions and freshness, every extra copy creates sync, access-control, and debugging work.

𝗔 𝗳𝗲𝘄 𝗽𝗿𝗮𝗰𝘁𝗶𝗰𝗮𝗹 𝗱𝗲𝘁𝗮𝗶𝗹𝘀 𝗺𝗮𝘁𝘁𝗲𝗿:
• External Collections are read-only and zero-copy.
• Milvus can index newly added fragments instead of rebuilding the whole collection.
• Three load mmilvus.io/docs/create-an…etween lower storage cost and lower latency.

Native Milvus collections are better for write-heavy serving. External Collections are for lake datasets that need production search without another copy.
Know the details: https://t.co/NR2QfOORyC

💬0🔄0❤️7👀275📊1

⚡ Powered by xgo.ing

How do you combine structured filters and keyword signals with semantic similarity in ecommerce sear...

Milvus (@milvusio) — Mon, 27 Jul 2026 15:30:00 GMT

How do you combine structured filters and keyword signals with semantic similarity in ecommerce search?

Take this query:
“pink headphones for kids with ears under $20”
“Pink headphones for kids with ears” expresses semantic intent. “Under $20” is a hard price constraint. Ratings, reviews, brand, category, and visual similarity may also influence the results.
𝗦𝗼 𝗲𝗰𝗼𝗺𝗺𝗲𝗿𝗰𝗲 𝗿𝗲𝘁𝗿𝗶𝗲𝘃𝗮𝗹 𝗻𝗲𝗲𝗱𝘀 𝗺𝗼𝗿𝗲 𝘁𝗵𝗮𝗻 𝘃𝗲𝗰𝘁𝗼𝗿 𝘀𝗲𝗮𝗿𝗰𝗵 𝗮𝗹𝗼𝗻𝗲.

Lumen, a demo built by @Simon Hearne, shows how these signals can work together in a small Amazon-style product search experience.

The app combines:
• Query understanding to separate product intent from numeric filters  
• Dense vector search for semantic relevance  
• BM25 for exact keyword matching  
• Milvus filters for price, rating, reviews, brand, and category  
• Text and image vectors for “More like this” recommendations

A diagnostics panel also makes the retrieval process visible, including the effective Milvus query, embedding dimension, fusion strategy, and latency.

That transparency matters. Search quality may feel subjective to users, but builders need to identify exactly which signal failed when the results feel wrong.

Lumen keeps the scope intentionally small: one catalog, one search flow, and one clear retrieval stack. It’s a useful example of the components modern product discovery often needs—hybrid retrieval, metadata filtering, multimodal similarity, and an API layer thatvdb-ecom.pages.devials segithub.com/simonhearne/ve…ps://t.co/nMg9Lf9bBo
Repo: https://t.co/XYw6BzRVV1

💬0🔄0❤️2👀246📊1

⚡ Powered by xgo.ing

Embedding model selection used to be mostly a leaderboard question. In 2026, it feels much closer t...

Milvus (@milvusio) — Fri, 24 Jul 2026 15:15:00 GMT

Embedding model selection used to be mostly a leaderboard question.

In 2026, it feels much closer to a data-shape question.

A text knowledge base, a scanned contract, a product screenshot, a financial report, and a video archive contain different retrieval signals. Sending all of them through the same chunking and embedding pipeline can discard the information that matters most.

𝗙𝗼𝗿 𝗻𝗼𝗿𝗺𝗮𝗹 𝘁𝗲𝘅𝘁 𝗞𝗕𝘀, dense embeddings are still the practical starting point. Qwen3 Embedding, Jina v5 text, BGE-M3, OpenAI text-embedding-3, Voyage, and Cohere are all worth testing against your real chunks.

𝗙𝗼𝗿 𝗣𝗗𝗙𝘀, 𝗶𝗺𝗮𝗴𝗲𝘀, 𝘀𝗰𝗿𝗲𝗲𝗻𝘀𝗵𝗼𝘁𝘀, 𝗮𝘂𝗱𝗶𝗼, 𝗮𝗻𝗱 𝘃𝗶𝗱𝗲𝗼, models like Gemini Embedding 2, Jina v5 omni, Cohere Embed 4, Qwen3-VL-Embedding, and Voyage Multimodal are making it easier to keep more original context in retrieval.

𝗙𝗼𝗿 𝗹𝗼𝗻𝗴 𝗱𝗼𝗰𝘂𝗺𝗲𝗻𝘁𝘀, contextualized chunk embeddings like Voyage context-4 address a painful issue: chunks often lose meaning when separated from the full document.

𝗙𝗼𝗿 𝗰𝗼𝗺𝗽𝗹𝗲𝘅 𝗹𝗮𝘆𝗼𝘂𝘁𝘀, ColPali-style multi-vector retrieval is worth a look, especially when tables, figures, page regions, or scanned details decide the answer.

Benchmarks like MTEB, MMEB, and ViDoRe are useful filters. But the final test still has to be your own documents, your own queries, and your own failure cases.

𝗠𝗶𝗹𝘃𝘂𝘀 𝟮.𝟲 also moves part of the embedding plumbing into the database layer: with Text Embedding Function, you can insert raw text, let Milvus call the configured embedding provider, store the vectors, and run text queries without managing embedding calls in every client.

We wrote a practical guide on how to choose embedding models for the second half of 2026.

💬0🔄1❤️1👀355📊1

⚡ Powered by xgo.ing

𝗠𝘂𝗹𝘁𝗶-𝗵𝗼𝗽 𝗥𝗔𝗚 𝘄𝗶𝘁𝗵𝗼𝘂𝘁 𝗮 𝗴𝗿𝗮𝗽𝗵 𝗱𝗮𝘁𝗮𝗯𝗮𝘀𝗲 Multi-hop retrieval is often ...

Milvus (@milvusio) — Thu, 23 Jul 2026 15:00:01 GMT

𝗠𝘂𝗹𝘁𝗶-𝗵𝗼𝗽 𝗥𝗔𝗚 𝘄𝗶𝘁𝗵𝗼𝘂𝘁 𝗮 𝗴𝗿𝗮𝗽𝗵 𝗱𝗮𝘁𝗮𝗯𝗮𝘀𝗲
Multi-hop retrieval is often solved by adding a separate graph store. We wanted to see how far we could get with Milvus alone — so we built an open-source library and found out.

Vector Graph RAG achieves multi-hop reasoning using only Milvus. Neo4j, Cypher queries, and the second system once needed to operate are all things of the past (in this scenario).

Vector Graph RAG is built upon the fact that knowledge graph relations are just text. An example, (metformin, is the first-line drug for, type 2 diabetes) is a directed edge in a graph database — but it's also a sentence you can embed and store in Milvus, alongside entities and source passages.

𝗩𝗲𝗰𝘁𝗼𝗿 𝗚𝗿𝗮𝗽𝗵 𝗥𝗔𝗚 𝘀𝘁𝗼𝗿𝗲𝘀 𝗲𝘃𝗲𝗿𝘆𝘁𝗵𝗶𝗻𝗴 𝗶𝗻 𝘁𝗵𝗿𝗲𝗲 𝗠𝗶𝗹𝘃𝘂𝘀 𝗰𝗼𝗹𝗹𝗲𝗰𝘁𝗶𝗼𝗻𝘀 𝘄𝗶𝘁𝗵 𝗜𝗗 𝗰𝗿𝗼𝘀𝘀-𝗿𝗲𝗳𝗲𝗿𝗲𝗻𝗰𝗲𝘀:• 𝗘𝗻𝘁𝗶𝘁𝗶𝗲𝘀 — deduplicated nodes, each carrying a list of the relation IDs they participate in
• 𝗥𝗲𝗹𝗮𝘁𝗶𝗼𝗻𝘀 — embedded triples pointing to the entity IDs and source passage IDs on each side
• 𝗣𝗮𝘀𝘀𝗮𝗴𝗲𝘀 — original document chunks with back-references to the extracted entities and relations

Those ID references are the graph structure. Subgraph expansion follows them to surface bridge entities that the question never mentions — the step that makes multi-hop reasoning work. Then a single LLM reranking pass filters the expanded candidate pool down to what actually answers the question, and one generation call produces the answer from the full source passages.

That pipeline makes 𝟮 𝗟𝗟𝗠 𝗰𝗮𝗹𝗹𝘀 𝗽𝗲𝗿 𝗾𝘂𝗲𝗿𝘆 (rerank + generate), compared to 3-5 for IRCoT and 5-10+ for Agentic RAG. Against a 5-call iterative baseline, that works out to roughly 𝟲𝟬% 𝗹𝗼𝘄𝗲𝗿 𝗔𝗣𝗜 𝗰𝗼𝘀𝘁 𝗮𝗻𝗱 𝟮-𝟯𝘅 𝗳𝗮𝘀𝘁𝗲𝗿 𝗿𝗲𝘀𝗽𝗼𝗻𝘀𝗲𝘀, with predictable latency instead of spikes when an agent decides to loop again.

On the benchmarks: 𝟴𝟳.𝟴% 𝗮𝘃𝗲𝗿𝗮𝗴𝗲 𝗥𝗲𝗰𝗮𝗹𝗹@𝟱 across MuSiQue, HotpotQA, and 2WikiMultiHopQA — against 𝟴𝟳.𝟭% for HippoRAG 2, under the same evaluation setup, with no graph database and no ColBERTv2.

𝗛𝗼𝘄github.com/zilliztech/vec…𝗹𝗹 𝘁𝗵𝗶𝘀? You only need to type"pip install vector-graph-rag". It defaults to Milvus Lite — a local .db file, so you don't need to configure anything. 
𝗙𝗼𝗿 𝗺𝗼𝗿𝗲 𝗶𝗻𝗳𝗼𝗿𝗺𝗮𝘁𝗶𝗼𝗻, 𝘀𝗲𝗲 𝗶𝘁𝘀 𝗴𝗶𝘁𝗵𝘂𝗯 𝗽𝗮𝗴𝗲: https://t.co/uyBstuGBcq

If your corpus is knowledge-dense — legal, biomedical, financial — and your questions routinely cross 2-4 document boundaries, this is the architecture worth testing first.

💬2🔄3❤️7👀338📊4

⚡ Powered by xgo.ing

Semantic search, full-text search, metadata filtering, and hybrid retrieval in one open-source syste...

Milvus (@milvusio) — Thu, 23 Jul 2026 06:22:07 GMT

Semantic search, full-text search, metadata filtering, and hybrid retrieval in one open-source system. Thanks to @DanKornas for sharing this clear overview of Milvus and the use cases it supports.

Dan Kornas@DanKornas

Need one retrieval layer for semantic search, full-text search, and metadata filtering?

Milvus is an open-source vector database for AI engineers building RAG, semantic search, multimodal search, and recommendation systems.

It helps you organize and search unstructured data by storing vectors alongside scalar fields, then combining vector search with metadata filters, full-text search, or hybrid retrieval.

Key features:

• Dense and sparse retrieval – supports semantic vectors, BM25 full-text search, and learned sparse embeddings.
• Hybrid search – stores dense and sparse vectors together and can rerank results from multiple searches.
• Multiple index types – includes HNSW, IVF, FLAT, SCANN, DiskANN, and quantized variants.
• Flexible deployment – runs as Milvus Lite, on one machine in Standalone mode, or in a distributed, Kubernetes-native architecture.
• Access controls – includes user authentication, TLS encryption, and role-based access control.

It’s open-source (Apache 2.0 license).

Link in the reply 👇

🔗 View Quoted Tweet

💬0🔄0❤️2👀325

⚡ Powered by xgo.ing

Everyone is talking about agent memory, but the term is starting to hide more than it explains. For...

Milvus (@milvusio) — Wed, 22 Jul 2026 15:00:01 GMT

Everyone is talking about agent memory, but the term is starting to hide more than it explains.

For coding agents, it is not just “save chat history, embed it, retrieve top-k” anymore.

These open-source projects show that “agent memory” can mean very different things:

1. codebase-memory-mcp
github.com/DeusData/codeb…

Memory as codebase structure: functions, classes, call chains, routes, dependencies, and impact paths.

2. MemSearch
github.com/zilliztech/mem…

Memory as retrieval infrastructure: Markdown as the source of truth, Milvus as the index, plus hybrid search and progressive recall.

3. agentmemory
github.com/rohitg00/agent…

Memory as workspace context that follows coding agents across Claude Code, Codex, Cursor, Gemini CLI, OpenCode, and MCP clients.

4. Basic Memory
github.com/basicmachines-…

Memory as a readable knowledge base: Markdown notes that humans can edit and agents can search.

5. ai-memory
github.com/akitaonrails/a…

Memory as continuity and handoff, so work can move between agent vendors without re-explaining architecture, failed attempts, and open questions.

These projects point to a simple trend: agent memory is moving from “store more context” to “retrieve the right context.”

For coding agents, memory is becoming less like a notes file and more like a retrieval layer.

💬2🔄0❤️2👀234📊3

⚡ Powered by xgo.ing

When 𝗞𝗶𝗺𝗶 𝗞𝟯 came out, we tested it right away. This is our experimental sharing: Kimi K3 has...

Milvus (@milvusio) — Tue, 21 Jul 2026 15:00:01 GMT

When 𝗞𝗶𝗺𝗶 𝗞𝟯 came out, we tested it right away. This is our experimental sharing:

Kimi K3 has 2.8T parameters, a 1M-token context window, native visual understanding, and strong coding-agent scores. After a few internal runs, we decided to move part of our workflow from Fable to K3.

The first surprise came from marketing.
One teammate in marketing used K3 to prototype a campaign landing page in one afternoon. Not production-ready, but enough to align the idea before involving engineering.

That was the good part.

The less fun part was the token bill.

Large-context coding agents can spend a lot of tokens just figuring out where things are in a repo. Kimi's pricing makes that visible: cache-hit input is $0.30/MTok, cache-miss input is $3.00/MTok, and output is $15.00/MTok.

So we added 𝗰𝗹𝗮𝘂𝗱𝗲-𝗰𝗼𝗻𝘁𝗲𝘅𝘁.

It gives coding agents semantic code search, so they retrieve relevant files and snippets instead of loading whole directories into the prompt.

In our controlled evaluation, Claude Context MCP reduced tokens by around 40% at equivalent retrieval quality.

K3 made the agent stronger. claude-context made it cheaper to aim that strength at the rigithub.com/zilliztech/cla…s://t.co/yyWCfHbgZv

💬0🔄0❤️4👀233📊1

⚡ Powered by xgo.ing

𝗛𝗼𝘄 𝗱𝗼 𝘆𝗼𝘂 𝗰𝗼𝗺𝗯𝗶𝗻𝗲 𝗮𝗴𝗲𝗻𝘁 𝗺𝗲𝗺𝗼𝗿𝘆 𝘄𝗶𝘁𝗵 𝘀𝗸𝗶𝗹𝗹𝘀? 𝗧𝗿𝘆 𝗼𝘂𝗿 ...

Milvus (@milvusio) — Mon, 20 Jul 2026 15:30:00 GMT

𝗛𝗼𝘄 𝗱𝗼 𝘆𝗼𝘂 𝗰𝗼𝗺𝗯𝗶𝗻𝗲 𝗮𝗴𝗲𝗻𝘁 𝗺𝗲𝗺𝗼𝗿𝘆 𝘄𝗶𝘁𝗵 𝘀𝗸𝗶𝗹𝗹𝘀? 𝗧𝗿𝘆 𝗼𝘂𝗿 𝗼𝗽𝗲𝗻-𝘀𝗼𝘂𝗿𝗰𝗲 𝘁𝗼𝗼𝗹 𝗺𝗲𝗺𝘀𝗲𝗿𝗮𝗰𝗵 𝘁𝗵𝗮𝘁'𝘀 𝘂𝗽𝗱𝗮𝘁𝗲𝗱 𝘁𝗵𝗲 𝗳𝗲𝗮𝘁𝘂𝗿𝗲, 𝗺𝗲𝗺𝗼𝗿𝘆-𝘁𝗼-𝘀𝗸𝗶𝗹𝗹.

𝗔𝗴𝗲𝗻𝘁 𝗺𝗲𝗺𝗼𝗿𝘆 𝘁𝗵𝗮𝘁'𝘀 𝗮𝗰𝘁𝘂𝗮𝗹𝗹𝘆 𝘃𝗮𝗹𝘂𝗮𝗯𝗹𝗲 𝗰𝗮𝗽𝘁𝘂𝗿𝗲𝘀 𝘁𝗵𝗿𝗲𝗲 𝘁𝗵𝗶𝗻𝗴𝘀: 𝘄𝗵𝗮𝘁 𝘁𝗵𝗲 𝗮𝗴𝗲𝗻𝘁 𝗸𝗻𝗼𝘄𝘀, 𝘄𝗵𝗮𝘁 𝗶𝘁 𝗵𝗮𝘀 𝗲𝘅𝗽𝗲𝗿𝗶𝗲𝗻𝗰𝗲𝗱, 𝗮𝗻𝗱 𝗵𝗼𝘄 𝗶𝘁 𝗱𝗼𝗲𝘀 𝘁𝗵𝗶𝗻𝗴𝘀.

Developers used to keep those in three separate systems: knowledge went into RAG, experience piled up in an agent memory layer, and procedures were written down as skill files.

But those memories — debug sessions, API integrations, releases, user corrections — are essentially part of the agent's skills too. Each one carries the scenario, the feedback, and the outcome. Plenty of reusable workflows are already hiding in there.

𝗦𝗼 𝘄𝗲 𝗯𝘂𝗶𝗹𝘁 𝗠𝗲𝗺𝗼𝗿𝘆-𝘁𝗼-𝗦𝗸𝗶𝗹𝗹 𝗶𝗻𝘁𝗼 𝗠𝗲𝗺𝗦𝗲𝗮𝗿𝗰𝗵, 𝘁𝗵𝗲 𝗮𝗴𝗲𝗻𝘁 𝗺𝗲𝗺𝗼𝗿𝘆 𝗹𝗶𝗯𝗿𝗮𝗿𝘆 𝘄𝗲 𝗼𝗽𝗲𝗻-𝘀𝗼𝘂𝗿𝗰𝗲𝗱 𝗲𝗮𝗿𝗹𝗶𝗲𝗿 𝘁𝗵𝗶𝘀 𝘆𝗲𝗮𝗿.

An opt-in background pass mines your history for the workflows that keep recurring and are worth capturing, then automatically distills them into candidate skills. If a release workflow keeps showing up, the system recognizes it can be abstracted into a skill and writes it up as a candidate file. When the workflow changes later, the candidate evolves with it.

𝗕𝘂𝘁 𝗻𝗼 𝗮𝗴𝗲𝗻𝘁 𝗲𝘃𝗲𝗿 𝗮𝘂𝘁github.com/zilliztech/mem…𝗱𝗶𝗱𝗮𝘁𝗲 𝘀𝗸𝗶𝗹𝗹. It stays a draft. You review it, edit it, confirm it, and then install it into the skill directory of Claude Code, Codex, or other agents you use.

𝗠𝗲𝗺𝗦𝗲𝗮𝗿𝗰𝗵 𝗶𝘀 𝗼𝗽𝗲𝗻 𝘀𝗼𝘂𝗿𝗰𝗲. 𝗜𝗳 𝘆𝗼𝘂'𝗿𝗲 𝗮𝗹𝘀𝗼 𝘄𝗼𝗿𝗸𝗶𝗻𝗴 𝗼𝗻 𝗮𝗴𝗲𝗻𝘁 𝗺𝗲𝗺𝗼𝗿𝘆, 𝗹𝗼𝗻𝗴-𝘁𝗲𝗿𝗺 𝗰𝗼𝗻𝘁𝗲𝘅𝘁, 𝗼𝗿 𝗰𝗿𝗼𝘀𝘀-𝗽𝗹𝗮𝘁𝗳𝗼𝗿𝗺 𝗔𝗜 𝘄𝗼𝗿𝗸𝗳𝗹𝗼𝘄𝘀, 𝗴𝗶𝘃𝗲 𝗶𝘁 𝗮 𝘁𝗿𝘆: https://t.co/eGAavvLonV

💬0🔄0❤️0👀192

⚡ Powered by xgo.ing

Semantic search in news feeds, e-commerce, and recommendation systems needs to balance relevance wit...

Milvus (@milvusio) — Fri, 17 Jul 2026 15:00:01 GMT

Semantic search in news feeds, e-commerce, and recommendation systems needs to balance relevance with freshness. 
𝗠𝗶𝗹𝘃𝘂𝘀 𝗽𝗿𝗼𝘃𝗶𝗱𝗲𝘀 𝘁𝗵𝗿𝗲𝗲 𝗱𝗲𝗰𝗮𝘆 𝗳𝘂𝗻𝗰𝘁𝗶𝗼𝗻𝘀 𝗳𝗼𝗿 𝗿𝗲𝗿𝗮𝗻𝗸𝗶𝗻𝗴. Three decay models are available, each producing a different freshness curve:
• 𝗘𝘅𝗽𝗼𝗻𝗲𝗻𝘁𝗶𝗮𝗹: fast initial decay with a long tail. News and social feeds where recency should dominate.
• 𝗚𝗮𝘂𝘀𝘀𝗶𝗮𝗻: bell-shaped curve with gradual roll-off. Balanced search like restaurant recommendations, where moderate distance should reduce rather than eliminate a result's score.
• 𝗟𝗶𝗻𝗲𝗮𝗿: constant penalty with a clear cutoff point. Event search where anything older than two weeks should not appear at all.

In this test, the query is "artificial intelligence advancements," against seven articles spanning 1 to 120 days old, under four ranking approaches.

No decay: pure semantic similarity.
• Ranking is determined entirely by L2 distance (lower = more similar). Time is invisible.
• Two articles with nearly identical content but published 90 days apart score the same: 0.7090. The 90-day-old article sits at #1.
• An article about "AI Ethics Guidelines" scores lowest because "ethics" is semantically farther from "advancements" than the other articles, even though it is also about AI.

Gaussian decay (offset: 7 days, scale: 14 days, decay: 0.5)
• The two newest articles (1-day and 5-day) jump to the top two positions. Both fall within the 7-day offset, so they receive no time penalty and rank by their original semantic similarity.
• A 15-day-old article drops to 0.3601 but stays visible. A 30-day-old article falls to 0.0642.
• Everything older than 60 days: 0.0000. The bell curve penalizes gradually at first, then sharply.

Exponential decay (offset: 3 days, scale: 10 days, decay: 0.3)
• A 1-day-old article scores 0.5979. A 5-day-old article drops to 0.4774 because it has already exceeded the 3-day offset, even though it is still relatively new.
• At 15 days: 0.1065, far below Gaussian's 0.3601 for the same article. At 30 days: nearly zero.
• Under this configuration, the steepest curve. It forgets faster than Gaussian and penalizes harder at every age beyond the offset.

Linear decay: the most gradual decline.
• A 90-day-old article still scores 0.3037. A 120-day-old article: 0.2339. Both score zero under Gaussian and exponential.
• Because the penalty is constant rather than accelerating, semantic relevance carries more weight relative to time. A highly relevant 90-day-old article outranks a weakly relevant 30-day-old one: the time penalty was not steep enough to override the stronger semantic match.
• The slope is gentle, but linear decay does reach zero at a clear cutoff point, giving you a predictable expiration boundary.
𝗖𝗵𝗼�milvus.io/docs/tutorial-…𝘃𝗲 𝗺𝗮𝘁𝘁𝗲𝗿𝘀 𝗺𝗼𝗿𝗲 𝘁𝗵𝗮𝗻 𝗰𝗵𝗼𝗼𝘀𝗶𝗻𝗴 𝘁𝗼 𝗮𝗱𝗱 𝗱𝗲𝗰𝗮𝘆.

Learn more here:https://t.co/72j2ip5E7I

💬0🔄0❤️1👀253📊1

⚡ Powered by xgo.ing

𝗜𝗻 𝗲-𝗰𝗼𝗺𝗺𝗲𝗿𝗰𝗲 𝗮𝗻𝗱 𝗻𝗲𝘄𝘀 𝘀𝗲𝗮𝗿𝗰𝗵, 𝘀𝗲𝗺𝗮𝗻𝘁𝗶𝗰 𝘀𝗶𝗺𝗶𝗹𝗮𝗿𝗶𝘁𝘆 ...

Milvus (@milvusio) — Thu, 16 Jul 2026 15:00:01 GMT

𝗜𝗻 𝗲-𝗰𝗼𝗺𝗺𝗲𝗿𝗰𝗲 𝗮𝗻𝗱 𝗻𝗲𝘄𝘀 𝘀𝗲𝗮𝗿𝗰𝗵, 𝘀𝗲𝗺𝗮𝗻𝘁𝗶𝗰 𝘀𝗶𝗺𝗶𝗹𝗮𝗿𝗶𝘁𝘆 𝗮𝗹𝗼𝗻𝗲 𝗶𝘀 𝗻𝗼𝘁 𝗲𝗻𝗼𝘂𝗴𝗵 𝘁𝗼 𝗿𝗮𝗻𝗸 𝗿𝗲𝘀𝘂𝗹𝘁𝘀. Milvus's Time-aware Ranking Functions (also called Decay Functions) rerank retrieval results by applying time-decay functions, so recent content ranks higher without sacrificing relevance. 

Milvus's Decay Functions combining vector similarity with configurable time-decay to dynamically adjust each document's relevance score. 𝗧𝗵𝗲 𝘀𝗰𝗼𝗿𝗶𝗻𝗴 𝘄𝗼𝗿𝗸𝘀 𝗶𝗻 𝘁𝗵𝗿𝗲𝗲 𝘀𝘁𝗲𝗽𝘀:
• 𝗖𝗼𝗻𝘃𝗲𝗿𝘁 𝗱𝗶𝘀𝘁𝗮𝗻𝗰𝗲𝘀 𝗶𝗻𝘁𝗼 𝗵𝗶𝗴𝗵𝗲𝗿-𝗶𝘀-𝗯𝗲𝘁𝘁𝗲𝗿 𝘀𝗰𝗼𝗿𝗲𝘀. For L2 and JACCARD (lower = more similar): normalized_score = 1.0 − (2 × arctan(score)) / π. COSINE, IP, and BM25 scores are used directly.
• 𝗖𝗼𝗺𝗽𝘂𝘁𝗲 𝗮 𝗱𝗲𝗰𝗮𝘆 𝘀𝗰𝗼𝗿𝗲 from a numeric field like a timestamp, using one of three decay models: exponential, Gaussian, or linear. The result is a value between 0 and 1, representing how close the document is to a reference point (typically "now").
• 𝗠𝘂𝗹𝘁𝗶𝗽𝗹𝘆: final_score = normalized_similarity_score × decay_score. In hybrid search with multiple vector fields, Milvus takes the maximum normalized score first: final_score = max(normalized_scores) × decay_score.

Each model takes a configurable origin, scale (the distance beyond thmilvus.io/docs/decay-ran…core drops to the decay value), and an optional offset (a no-penalty zone around the origin where the score stays at 𝟭.𝟬).

𝗟𝗲𝗮𝗿𝗻 𝗺𝗼𝗿𝗲 𝗵𝗲𝗿𝗲: https://t.co/PLK2ouE4Dt

💬0🔄1❤️2👀231📊1

⚡ Powered by xgo.ing

𝗚𝗿𝗲𝗽-𝘀𝘁𝘆𝗹𝗲 𝘀𝗲𝗮𝗿𝗰𝗵 𝗶𝗻 𝗖𝗹𝗮𝘂𝗱𝗲 𝗖𝗼𝗱𝗲 𝘄𝗼𝗿𝗸𝘀 𝗳𝗼𝗿 𝗰𝗼𝗱𝗲 ...

Milvus (@milvusio) — Wed, 15 Jul 2026 15:30:00 GMT

𝗚𝗿𝗲𝗽-𝘀𝘁𝘆𝗹𝗲 𝘀𝗲𝗮𝗿𝗰𝗵 𝗶𝗻 𝗖𝗹𝗮𝘂𝗱𝗲 𝗖𝗼𝗱𝗲 𝘄𝗼𝗿𝗸𝘀 𝗳𝗼𝗿 𝗰𝗼𝗱𝗲 𝗿𝗲𝘁𝗿𝗶𝗲𝘃𝗮𝗹, 𝗯𝘂𝘁 𝗶𝘁 𝗯𝘂𝗿𝗻𝘀 𝘁𝗵𝗿𝗼𝘂𝗴𝗵 𝘁𝗼𝗸𝗲𝗻𝘀 𝘂𝗻𝗻𝗲𝗰𝗲𝘀𝘀𝗮𝗿𝗶𝗹𝘆. 𝗪𝗲 𝗯𝘂𝗶𝗹𝘁 𝗖𝗹𝗮𝘂𝗱𝗲 𝗖𝗼𝗻𝘁𝗲𝘅𝘁, 𝗮𝗻 𝗼𝗽𝗲𝗻-𝘀𝗼𝘂𝗿𝗰𝗲 𝗠𝗖𝗣 𝘁𝗼𝗼𝗹 𝘁𝗵𝗮𝘁 𝗰𝘂𝘁𝘀 𝘁𝗼𝗸𝗲𝗻 𝘂𝘀𝗮𝗴𝗲 𝗯𝘆 ~𝟰𝟬%.

Grep-style code retrieval has drawn plenty of community discussion. For pure recall, literal matching gets the job done. But in a large codebase, it forces the model to wade through massive amounts of irrelevant code to find the few lines that matter.

𝗧𝗵𝗿𝗲𝗲 𝘁𝗵𝗶𝗻𝗴𝘀 𝗺𝗮𝗸𝗲 𝘁𝗵𝗶𝘀 𝗲𝘅𝗽𝗲𝗻𝘀𝗶𝘃𝗲 𝗮𝘁 𝘀𝗰𝗮𝗹𝗲:
• 𝗜𝗻𝗳𝗼𝗿𝗺𝗮𝘁𝗶𝗼𝗻 𝗼𝘃𝗲𝗿𝗹𝗼𝗮𝗱. Large repos produce hundreds of literal matches for common terms. Most are noise, but they all consume tokens and inference time.
• 𝗦𝗲𝗺𝗮𝗻𝘁𝗶𝗰 𝗯𝗹𝗶𝗻𝗱𝗻𝗲𝘀𝘀. Grep matches characters, not meaning. compute_final_cost() and calculate_total_price() do the same thing, but a string match won't connect them.
• 𝗜𝗻𝗰𝗼𝗺𝗽𝗹𝗲𝘁𝗲 𝗰𝗼𝗻𝘁𝗲𝘅𝘁. Line-level matches strip away the surrounding class and method structure. The model compensates by reading more files, burning more tokens.

𝗪𝗲 𝗼𝗽𝗲𝗻-𝘀𝗼𝘂𝗿𝗰𝗲𝗱 𝗖𝗹𝗮𝘂𝗱𝗲 𝗖𝗼𝗻𝘁𝗲𝘅𝘁 𝘁𝗼 𝗮𝗱𝗱𝗿𝗲𝘀𝘀 𝗲𝘅𝗮𝗰𝘁𝗹𝘆 𝘁𝗵𝗶𝘀. 𝗜𝘁 𝗵𝗶𝘁 #𝟭 𝗼𝗻 𝗚𝗶𝘁𝗛𝘂𝗯'𝘀 𝗱𝗮𝗶𝗹𝘆 𝘁𝗿𝗲𝗻𝗱𝗶𝗻𝗴 𝗰𝗵𝗮𝗿𝘁 𝗮𝗻𝗱 𝗰𝘂𝗿𝗿𝗲𝗻𝘁𝗹𝘆 𝗵𝗮𝘀 𝗼𝘃𝗲𝗿 𝟭𝟮,𝟬𝟬𝟬 𝘀𝘁𝗮𝗿𝘀.

𝗜𝗻 𝗼𝘂𝗿 𝗯𝗲𝗻𝗰𝗵𝗺𝗮𝗿𝗸, 𝗖𝗹𝗮𝘂𝗱𝗲 𝗖𝗼𝗻𝘁𝗲𝘅𝘁 𝗿𝗲𝗱𝘂𝗰𝗲𝗱 𝘁𝗼𝗸𝗲𝗻 𝗰𝗼𝗻𝘀𝘂𝗺𝗽𝘁𝗶𝗼𝗻 𝗯𝘆 ~𝟰𝟬% 𝗮𝘁 𝗲𝗾𝘂𝗶𝘃𝗮𝗹𝗲𝗻𝘁 𝗿𝗲𝘁𝗿𝗶𝗲𝘃𝗮𝗹 𝗾𝘂𝗮𝗹𝗶𝘁𝘆.
It's a code retrieval MCP server that integrates a vector database and embedding model into the search layer. It plugs into Claude Code and is also compatible with Codex CLI, Gemini CLI, Qwen Code, Cline, Cursor, Windsurf, and other MCP-compatible agents.

𝗜𝘁 𝗱𝗼𝗲𝘀 𝘁𝗵𝗿𝗲𝗲 𝘁𝗵𝗶𝗻𝗴𝘀 𝗱𝗶𝗳𝗳𝗲𝗿𝗲𝗻𝘁𝗹𝘆:
• 𝗦𝗺𝗮𝗿𝘁 𝗳𝗶𝗹𝘁𝗲𝗿𝗶𝗻𝗴. Vector similarity ranks code by relevance, surfacing the most related results first instead of every literal match.
• 𝗖𝗼𝗻𝗰𝗲𝗽𝘁 𝗺𝗮𝘁𝗰𝗵𝗶𝗻𝗴. Dense retrieval can match conceptually related code even when function names differ entirely.
• 𝗖𝗼𝗻𝘁𝗲𝘅𝘁-𝗮𝘄𝗮𝗿𝗲 𝗿𝗲𝘁𝗿𝗶𝗲𝘃𝗮𝗹. Results are chunked around complete syntactic units (functions, classes, methods), giving the model enough structural context to reason about behavior.

Under the hood, Claude Context uses MCP as its interface layer and Milvus for codebase indexing and hybrid search (BM25 + dense vectors). Embeddings support OpenAI, VoyageAI (which ships a code-specific model), and Ollama for local deployment when privacy matters.

Cgithub.com/zilliztech/cla…arsing by default, splitting along semmilvus.io/blog/claude-co…d of cutting at arbitrary line counts. For files AST can't parse, LangChain's text splitter handles the fallback.

For incremental updates, Claude Context uses Merkle-tree change detection. If the root hash hasn't changed, the index stays untouched. When it changes, the system identifies exactly which files were modified and re-embeds only those.

Change one function, and you don't re-index the entire project.

🔗 https://t.co/yyWCfHbgZv

 📝 Full benchmark and architecture: https://t.co/Sevmvp37HT

💬0🔄4❤️10👀720📊4