Milvus(@milvusio)

🎙️ Join our Founding Solutions Architect, 𝗬𝘂𝗹𝗮𝗻 𝗬𝗮𝗻, online on 𝟮𝟮 𝗢𝗰𝘁𝗼𝗯𝗲𝗿 for the ...

Milvus (@milvusio) — Mon, 19 Oct 2026 08:30:58 GMT

🎙️ Join our Founding Solutions Architect, 𝗬𝘂𝗹𝗮𝗻 𝗬𝗮𝗻, online on 𝟮𝟮 𝗢𝗰𝘁𝗼𝗯𝗲𝗿 for the 𝟲𝟵𝘁𝗵 𝗠𝗟𝗢𝗽𝘀/𝗟𝗟𝗠𝗢𝗽𝘀/𝗔𝗴𝗲𝗻𝘁𝗢𝗽𝘀 𝗦𝘁𝘂𝗱𝘆 𝗦𝗲𝘀𝘀𝗶𝗼𝗻!

With Milvus and Zilliz Cloud examples, Yulan will share architecture patterns for keeping production retrieval systems adaptable as data, models, and requirements change—from ETL and embeddings to serving, evaluation, and observability.

💬 Have a retrieval challenge to discuss? Take it to the Qmlops.connpass.com/event/408179/save your place for 𝟭𝟵:𝟬𝟬 𝗝𝗦𝗧: https://t.co/33EEOMLkOZ

Zilliz@zilliz_universe

🇯🇵 𝗗𝗶𝘀𝗰𝗼𝘃𝗲𝗿 𝗵𝗼𝘄 𝘁𝗼 𝗯𝘂𝗶𝗹𝗱 𝗿𝗲𝘁𝗿𝗶𝗲𝘃𝗮𝗹 𝘀𝘆𝘀𝘁𝗲𝗺𝘀 𝘁𝗵𝗮𝘁 𝗲𝘃𝗼𝗹𝘃𝗲—𝗼𝗻𝗹𝗶𝗻𝗲 𝗼𝗻 𝟮𝟮 𝗢𝗰𝘁𝗼𝗯𝗲𝗿!

Zilliz’s Founding Solutions Architect Yulan Yan will speak at the 𝟲𝟵𝘁𝗵 𝗠𝗟𝗢𝗽𝘀/𝗟𝗟𝗠𝗢𝗽𝘀/𝗔𝗴𝗲𝗻𝘁𝗢𝗽𝘀 𝗦𝘁𝘂𝗱𝘆 𝗦𝗲𝘀𝘀𝗶𝗼𝗻, hosted by Japan’s MLOps community. She’ll discuss how to design production retrieval systems that can evolve as data, models, and use cases grow.

Her session, “Designing and Operating Production Retrieval Systems That Withstand Change,” covers the retrieval lifecycle, from ETL and embedding pipelines to serving, evaluation, and observability. Drawing on Milvus and Zilliz Cloud examples, she’ll explain architecture patterns that help retrieval infrastructure adapt to changing production requirements.

The session includes a Q&A for your questions about retrieval design and operations.

📅 𝗧𝗵𝘂𝗿𝘀𝗱𝗮𝘆, 𝟮𝟮 𝗢𝗰𝘁𝗼𝗯𝗲𝗿 𝟮𝟬𝟮𝟲 · 𝗢𝗻𝗹𝗶𝗻𝗲 𝗳𝗿𝗼𝗺 𝟭𝟵:𝟬𝟬 𝗝𝗦𝗧

💡 Working on retrieval beyond the mlops.connpass.com/event/408179/line session offers a chance to learn from practical architecture examples.
Register early and reserve your place: https://t.co/QjU1GAsyjS

🔗 View Quoted Tweet

💬0🔄2❤️1👀267📊1

⚡ Powered by xgo.ing

"Code only" vs. "Code with explanation"—similar questions don't always mean identical requirements. ...

Milvus (@milvusio) — Fri, 16 Oct 2026 15:15:00 GMT

"Code only" vs. "Code with explanation"—similar questions don't always mean identical requirements. That's why traditional semantic caching often breaks.

To solve this, Zilliz CTO James Luan tested 𝗝𝗲𝘃, a budget-friendly model that acts as a gateway guard before serving cached outputs.

Jev evaluates 5 critical dimensions in real time:
• 𝗧𝗮𝘀𝗸 𝗙𝗶𝘁: Does the answer directly solve the current query?
• 𝗖𝗼𝗻𝘀𝘁𝗿𝗮𝗶𝗻𝘁 𝗠𝗮𝘁𝗰𝗵: Does it meet specific parameters (e.g., region, version, limits)?
• 𝗙𝗼𝗿𝗺𝗮𝘁 & 𝗖𝗼𝗺𝗽𝗹𝗲𝘁𝗲𝗻𝗲𝘀𝘀: Is it fully complete in the requested style and language?
• 𝗧𝗶𝗺𝗲 𝗦𝗲𝗻𝘀𝗶𝘁𝗶𝘃𝗶𝘁𝘆: Does it rely on outdated or changing data?
• 𝗖𝗼𝗻𝘁𝗲𝘅𝘁 𝗔𝘃𝗮𝗶𝗹𝗮𝗯𝗶𝗹𝗶𝘁𝘆: Is all required context present to support the response?

The test results on 1,152 real-world examples:
• 𝗭𝗲𝗿𝗼 𝗶𝗻𝗰𝗼𝗿𝗿𝗲𝗰𝘁 𝗿𝗲𝘂𝘀𝗲𝘀 recorded.
• 𝟮𝟮𝟳 𝘃𝗮𝗹𝗶𝗱 𝗿𝗲𝘀𝗽𝗼𝗻𝘀𝗲𝘀 𝘀𝗮𝘃𝗲𝗱, avoiding costly re-generations.
• 𝗠𝗲𝗱𝗶𝗮𝗻 𝗹𝗮𝘁𝗲𝗻𝗰𝘆 𝗽𝗲𝗻𝗮𝗹𝘁𝘆: Only 0.79s.

Semantic caching is a tradeoff between LLM costs and response accuracy. Jev shows that adding milvus.io/blog/jevs-chea…that tradeoff significantly safer.

Check out the complete benchmark breakdown (feat. Laya and GPTCache reranker):
https://t.co/mHFX3wo3PF

💬1🔄0❤️1👀265📊1

⚡ Powered by xgo.ing

In product search, the closest semantic match isn’t always the best result once price, freshness, po...

Milvus (@milvusio) — Thu, 15 Oct 2026 15:46:00 GMT

In product search, the closest semantic match isn’t always the best result once price, freshness, popularity, and ratings enter the picture.

In this demo, we show how 𝗠𝗶𝗹𝘃𝘂𝘀 𝗙𝘂𝗻𝗰𝘁𝗶𝗼𝗻 𝗖𝗵𝗮𝗶𝗻 𝗰𝗼𝗺𝗯𝗶𝗻𝗲𝘀 𝘀𝗲𝗺𝗮𝗻𝘁𝗶𝗰 𝘀𝗶𝗺𝗶𝗹𝗮𝗿𝗶𝘁𝘆 with business signals such as price, freshness, popularity, and rating. It then uses an XGBoost model to rerank the results—all inside Milvus and in a single search call.

You can also apply the same approach to news feeds, community content, knowledge bases, and other search systems where relevance idemos.milvus.io/function-chain…
🔗 Try the live demo:
https://tgithub.com/zc277584121/mi…ore the code on GitHub:
https://t.co/yDdf0tIO5f

Your browser does not support the video tag.

🔗 View on Twitter

💬5🔄2❤️12👀378📊8

⚡ Powered by xgo.ing

One self-driving car can record terabytes of video in a day. But engineers don’t need all that foot...

Milvus (@milvusio) — Wed, 14 Oct 2026 15:40:00 GMT

One self-driving car can record terabytes of video in a day.

But engineers don’t need all that footage. They need a few seconds when something important happened.

A pedestrian crossed the road at night. A car cut near a highway exit. Roadwork appeared during heavy rain.

Finding those moments by watching video after video doesn’t scale.

A vision model can turn each frame into a vector and extract details such as the weather, road type, traffic-light color, lane count, and unusual events. Milvus stores and indexes those vectors and details so teams can search them together.

Then an engineer can:
     Type “rainy construction zone with traffic cones,” let the application convert that text into a vector, filter the results by weather, and jump to the matching clip and timestamp.

The same setup also works with a reference image. The application converts the image into a vector, and Milvus finds the closest road scenes.

This gives autonomous-driving teams a practical way to find rare cases, review model failures, and collect useful training data.

The same approach can help teams search for factory inspection images, robot camera footage, security video, and other large visual datasets.

Try the demo: demos.milvus.io/structarray-se…

💬0🔄0❤️3👀219📊1

⚡ Powered by xgo.ing

We tested whether Jev could replace some of the LLM calls inside three agentic search workloads. 1...

Milvus (@milvusio) — Tue, 13 Oct 2026 15:50:00 GMT

We tested whether Jev could replace some of the LLM calls inside three agentic search workloads.

1️⃣ In 𝗗𝗲𝗲𝗽𝗦𝗲𝗮𝗿𝗰𝗵𝗲𝗿, Jev matched DeepSeek Flash at 93.25% Recall@5. Median latency for the stopping decision fell from 2.23 seconds to 0.55, while estimated cost was about 7.5x lower.
For this kind of narrowly defined stopping decision, Jev can replace the general-purpose LLM without sacrificing aggregate retrieval quality.

2️⃣ In 𝗠𝗲𝗺𝗦𝗲𝗮𝗿𝗰𝗵, Jev raised Recall@5 from 74.71% to 79.41%. Voyage rerank-3 still performed better, reaching 81.87% at a lower cost.
For this workload, the dedicated reranker remains the better choice: higher retrieval quality at a lower cost.

3️⃣ In 𝗩𝗲𝗰𝘁𝗼𝗿 𝗚𝗿𝗮𝗽𝗵 𝗥𝗔𝗚, Jev beat GPT-4o-mini on HotpotQA and MuSiQue. It came within one point of GPT-5-mini on HotpotQA, but trailed it by 4.13 points on MuSiQue.
Jev is a viable option when latency matters and some loss in recall is acceptable, but a stronger generative model remains better for difficult multi-hop retrieval.

Overall, Jev worked best for frequent, bounded semantic decisions. Its advantage narrowed when a specialized model already fit the task or when the decision required reasoning across multiple pieces omilvus.io/blog/jev-vs-ll…ll results: https://t.co/7NdCtU1XFu

💬0🔄4❤️12👀722📊5

⚡ Powered by xgo.ing

🎤 Our Solutions Architect, Yulan Yan, will speak at Tokyo AI’s 𝗥𝗲𝗹𝗶𝗮𝗯𝗹𝗲 𝗮𝗴𝗲𝗻𝘁𝘀: ...

Milvus (@milvusio) — Mon, 12 Oct 2026 00:36:50 GMT

🎤 Our Solutions Architect, Yulan Yan, will speak at Tokyo AI’s 𝗥𝗲𝗹𝗶𝗮𝗯𝗹𝗲 𝗮𝗴𝗲𝗻𝘁𝘀: 𝗺𝗲𝗺𝗼𝗿𝘆, 𝗲𝘅𝗲𝗰𝘂𝘁𝗶𝗼𝗻 𝘀𝘁𝗮𝘁𝗲 𝗮𝗻𝗱 𝗿𝗲𝗰𝗼𝘃𝗲𝗿𝘆 in Tokyo on 14 October!

Her talk, “Agent Memory in Production: Patterns from Real-World AI Applications,” will explore four recurring memory patterns across AI companions, enterprise agents, robotics, and personal AI devices. Drawing on systems using Milvus and Zilliz Cloud, she’ll examine what to remember, when to consolidate interactions, and how to prioritise recent and older memories as applications evolve.

📣 𝗕𝗿luma.com/9sta84i8�𝘁 𝗺𝗲𝗺𝗼𝗿𝘆 𝗾𝘂𝗲𝘀𝘁𝗶𝗼𝗻𝘀! 𝗥𝗲𝗴𝗶𝘀𝘁𝗲𝗿 𝘁𝗼𝗱𝗮𝘆: https://t.co/PdK7uK0m0z

Zilliz@zilliz_universe

🇯🇵 Join us in Tokyo on 14 October for a talk on agent memory!

On 14 October, Zilliz’s Solutions Architect Yulan Yan will take part in 𝗥𝗲𝗹𝗶𝗮𝗯𝗹𝗲 𝗮𝗴𝗲𝗻𝘁𝘀: 𝗺𝗲𝗺𝗼𝗿𝘆, 𝗲𝘅𝗲𝗰𝘂𝘁𝗶𝗼𝗻 𝘀𝘁𝗮𝘁𝗲 𝗮𝗻𝗱 𝗿𝗲𝗰𝗼𝘃𝗲𝗿𝘆, organised by Tokyo AI (TAI). Together, we’ll explore how agents retain useful context, keep track of their work, and continue after interruptions.

🎤 𝗠𝗲𝗲𝘁 𝘁𝗵𝗲 𝘀𝗽𝗲𝗮𝗸𝗲𝗿𝘀
→ Yulan Yan, Solutions Architect at Zilliz, will share production memory patterns across AI companions, enterprise agents, robotics, and personal AI devices. Learn how teams use Milvus and Zilliz Cloud for memory storage and retrieval, and how they keep memories relevant and up to date.

→ Melanie Warrick, AI & DevRel Engineer at Temporal, will examine the difference between what an agent knows and what it has already done. Her live demo will illustrate why task memory alone isn’t enough to resume work reliably.

→ Koji Annoura, Co-founder of Neo4j Users Group Tokyo, will demonstrate how agents can share persistent context through Neo4j and MCP, preserving useful knowledge across models and sessions.

Bring your questions for the Q&As and stay to exchange ideas with fellow engineers, architects, and technical leads.

📅 Wednesday, 14 October 2026 · 18:00–21:00 JST
🚀 We’d love to see you in Tokyo and exchange ideas on agenluma.com/9sta84i8y! Register today to join the discussion: https://t.co/1XLimRm9c3

🔗 View Quoted Tweet

💬0🔄0❤️0👀296

⚡ Powered by xgo.ing

Single-vector retrieval is a useful default. But on visually dense PDFs, it can become lossy: diagra...

Milvus (@milvusio) — Fri, 09 Oct 2026 15:31:00 GMT

Single-vector retrieval is a useful default. But on visually dense PDFs, it can become lossy: diagrams, labels, arrows, and spatial relationships get compressed into one representation, even when a query depends on one local detail.

This Milvus 3.0 demo takes a different approach:
Query → a list of token embeddings
PDF page → a list of visual patch embeddings
Ranking → late interaction with MAX_SIM_COSINE

In one line:
score(Q, P) = Σᵢ maxⱼ cosine(qᵢ, pⱼ)

For each query token, Milvus finds the most relevant region on the page, then combines those best matches into a page-level score.

This keeps fine-grained visual signals intact until the moment of comparison.

The demo applies the approach to pages from the NASA Systems Engineering Handbook, making it easy to see visual PDF retrieval working end to end.

If you work with engineering manuals, scientific papers, financial reports, or slide decks, it’s worth a look.
Explore the live demo: demos.milvus.io/embedding-list/

Your browser does not support the video tag.

🔗 View on Twitter

💬1🔄3❤️13👀727📊6

⚡ Powered by xgo.ing

𝗪𝗲’𝗿𝗲 𝗯𝗿𝗶𝗻𝗴𝗶𝗻𝗴 𝘁𝗵𝗲 𝗠𝗶𝗹𝘃𝘂𝘀 𝟯.𝟬 𝗠𝗲𝗲𝘁𝘂𝗽 𝘁𝗼 𝗦𝗮𝗻 𝗙𝗿𝗮𝗻𝗰𝗶𝘀𝗰𝗼 ...

Milvus (@milvusio) — Fri, 09 Oct 2026 03:56:39 GMT

𝗪𝗲’𝗿𝗲 𝗯𝗿𝗶𝗻𝗴𝗶𝗻𝗴 𝘁𝗵𝗲 𝗠𝗶𝗹𝘃𝘂𝘀 𝟯.𝟬 𝗠𝗲𝗲𝘁𝘂𝗽 𝘁𝗼 𝗦𝗮𝗻 𝗙𝗿𝗮𝗻𝗰𝗶𝘀𝗰𝗼 𝗼𝗻 𝗢𝗰𝘁𝗼𝗯𝗲𝗿 𝟮𝟭. 🚀

Milvus is expanding beyond vector search into a broader retrieval engine—combining vector, full-text, and structured search over data stored in open lake formats.

Come hear directly from the people building and running these systems:
→ 𝗝𝗶𝗮𝗻𝗴 𝗖𝗵𝗲𝗻, Head of Developer Relations and Solutions at Milvus/Zilliz — “Milvus 3.0: A More Powerful Retrieval Engine.” He’ll unpack lake-native External Collections, searching vector, full-text, JSON, and scalar data over lake files, and new capabilities such as sorting, aggregation, faceted search, and nested documents.

→ 𝗣𝗿𝗲𝗺𝗮𝗹 𝗦𝗵𝗮𝗵, Co-Founder and Chief Architect at 6sense — “Large Scale Entity Resolution with Milvus at 6sense.” He’ll share how 6sense uses Milvus for entity resolution across very large datasets.

→ 𝗔𝗺𝗶𝘁 𝗦𝗵𝗮𝗿𝗺𝗮, Senior Manager at AWS Partner, will join us for the 7:30 PM session.

If you’re building search, ML infrastructure, data platforms, or production retrieval systems, come ready for real architecture, practical tradeoffs, and hard questions.

📅 Wednesday, October 21 · 5:30–9:00 PM PDT
📍 525luma.com/0n3ztif1#Milvusn#VectorDatabased#AIInfrastructureking
Save your spot 👇
https://t.co/pUvpJprSCH#Milvus#VectorDatabase#AIInfrastructure

💬1🔄0❤️0👀316📊2

⚡ Powered by xgo.ing

Millions of questions. How does Milvus help find the right one? Traditional full-text retrieval fin...

Milvus (@milvusio) — Wed, 07 Oct 2026 15:45:00 GMT

Millions of questions. How does Milvus help find the right one?

Traditional full-text retrieval finds questions through the words they contain. In a growing question bank, students and teachers also need questions that test similar concepts with different wording and fit the intended curriculum and difficulty level.

To support these needs, this Milvus-based architecture combines semantic retrieval, BM25 keyword search, and scalar filtering in a five-step pipeline:

1. Data collection and cleaning. Collect question text, explanations, and metadata; standardize fields such as course, education level, concepts, and difficulty.

2. Vectorization. Use education-tuned embeddings for semantic matching and Milvus’s built-in BM25 function for keyword retrieval.

3. Hybrid index construction. Create HNSW/COSINE indexes for dense vectors, sparse indexes for BM25, and scalar indexes for metadata filtering.

4. Hybrid retrieval. Combine semantic and keyword search under metadata constraints, then merge results with WeightedRanker or RRFRanker.

5. Reranking and output. Use a Cross-Encoder to rerank candidates for test assembly, mistake-based review recommendations, and search by question.

The design pairs semantic matching with lexical relevance and explicit teaching constraints, helping students and teachers find questions suited to their learning tasks.

#Milvus#EdTech

💬0🔄1❤️6👀459📊2

⚡ Powered by xgo.ing

SQ, PQ, or PRQ: how do they compress vectors in Milvus HNSW? HNSW can deliver high recall, but its ...

Milvus (@milvusio) — Mon, 05 Oct 2026 15:30:01 GMT

SQ, PQ, or PRQ: how do they compress vectors in Milvus HNSW?

HNSW can deliver high recall, but its full precision vectors and layered graph consume substantial memory. Milvus offers HNSW_SQ, HNSW_PQ, and HNSW_PRQ to compress the vectors used in graph construction and distance calculations.

Each method encodes vectors differently:
• SQ quantizes each dimension. SQ8 and SQ6 use 8 and 6 bits per dimension, with independently estimated ranges. SQ4U uses 4-bit unsigned values and one shared uniform range.

• PQ splits the vector into subvectors. Each subvector is represented by a codebook index.

• PRQ starts with PQ, then encodes residual error in stages. It retains additional information beyond the initial approximation, with additional training, build, and distance calculation costs.

All three quantized index variants use the same HNSW framework, but quantization can change which vectors are connected during construction and how candidates are ranked during retrieval. They can also use higher precision refinement to rerank candidates and potentially improve recall, while adding compute, storage, and memory costs.

To compare SQ, PQ, and PRQ, set a recall target first, then measure memory after loading, throughput, and build time—including the cost of any refinement needed to reach that target.

💬0🔄1❤️1👀283📊1

⚡ Powered by xgo.ing

Real-world data is rarely flat. A driving video, for example, has an overall scene—an intersection,...

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

Real-world data is rarely flat.

A driving video, for example, has an overall scene—an intersection, a highway ramp, a residential street—but it also contains dozens of individual observations: vehicles, colors, positions, movements, and more.

Finding the right video often means searching both levels at once.

Our new StructArray Hybrid Search demo shows how Milvus 3.0 makes that possible. With a query like “a white truck waiting at an intersection,”

Milvus can:
• understand the intersection at the video level
• identify the white truck within nested observations
• combine both signals into one ranked result

StructArray keeps parent records and their child elements together, while still allowing vectors inside those nested elements to be searched directly. That means less data modeling complexity—and more context preserved during retrieval.

If you’re building search for multimodal datasets, documents with sections, products with variants, or any other parent-child data, this pattern is worth exploring.

Try it now: demos.milvus.io/structarray-se…
GitHub Code: github.com/zc277584121/mi…

💬2🔄2❤️7👀578📊4

⚡ Powered by xgo.ing

Jev is built to decide, not to chat. That makes it a surprisingly good fit for search. Milvus first...

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

Jev is built to decide, not to chat. That makes it a surprisingly good fit for search.

Milvus first retrieves candidate passages with vector search and metadata filters. Jev then looks at those passages and judges whether they actually help with the task.

In practice, the flow looks like this:
Query -> Milvus retrieves -> Jev judges -> your application acts

For the common reranking case, JevRerankFunction takes a query, candidate documents, and top_k, then returns them scored and reordered.

We also put together nine small tutorials to show what else this pattern can do: route a query, check whether a cached answer can be reused, screen documents before indexing, or decide whether an agent has enough evidence to stop searching.

Each example uses a small dataset, so it's easy to follow what Milvus retrieved, what Jev decided, and what happened next.

Pick the example that feels closest to what you're building and give it a try.
Try it now: milvus.io/docs/search_wi…

💬2🔄1❤️5👀418📊4

⚡ Powered by xgo.ing

🇫🇷 Paris, we’re coming! On October 7, the Milvus community is getting together at Criteo’s Paris o...

Milvus (@milvusio) — Mon, 28 Sep 2026 06:34:33 GMT

🇫🇷 Paris, we’re coming!
On October 7, the Milvus community is getting together at Criteo’s Paris office for an evening on the hard parts of vector search—how Criteo, Gorgias, and Milvus are scaling retrieval in production.

🎤 We'll hear from practitioners at Milvus/Zilliz, Criteo, and Gorgias:
→ Simon Hearne, Solutions Architect at Zilliz, will make vector indexes visual, including where recall drops and why.
→ Mehdi Sebbar, Staff ML Engineer for AI for Agentic Commerce at Criteo, and Erenus Dermanci, Site Reliability Engineer on Criteo’s R&D Platform, will share how a product need became a distributed vector search system—and the pain points they encountered along the way.
→ Mohamed Ali Fathallah, Senior Machine Learning Engineer at Gorgias, and Othmane Jebbari, Machine Learning Engineer at Gorgias, will unpack the RAG indexing patterns their team developed under two years of scaling pressure.
Stay for drinks and a chance to meet others working on search and AI.

📅 Wednesday, 7 October 2026 · 18:00–22:00 CEST
📍 Criteo’s Paris office · arrival details sent after registration is confirmed
🗣️ Talks in English

🚀 Come join us in Paris and share what you’re building! Space is limited, so register luma.com/bfo1andhO3eS9Fb

💬0🔄0❤️2👀724📊1

⚡ Powered by xgo.ing

A shopper searching for “a compact dark wood desk for a small home office” cares about semantic rele...

Milvus (@milvusio) — Thu, 24 Sep 2026 15:35:00 GMT

A shopper searching for “a compact dark wood desk for a small home office” cares about semantic relevance. A commerce ranking may also need to consider rating, popularity, price, and freshness.

𝗧𝗵𝗲 𝗠𝗶𝗹𝘃𝘂𝘀 𝟯.𝟬 𝗙𝘂𝗻𝗰𝘁𝗶𝗼𝗻 𝗖𝗵𝗮𝗶𝗻 𝗿𝗲𝗿𝗮𝗻𝗸 𝗱𝗲𝗺𝗼 𝘀𝗵𝗼𝘄𝘀 𝗵𝗼𝘄 𝘁𝗼 𝗰𝗼𝗺𝗯𝗶𝗻𝗲 𝘁𝗵𝗲𝗺 𝗶𝗻 𝗼𝗻𝗲 𝗿𝗲𝘁𝗿𝗶𝗲𝘃𝗮𝗹 𝗽𝗮𝘁𝗵:
• BGE-M3 converts the query into an embedding.
• Milvus runs COSINE vector search and recalls the top 20 products.
• A server-side Function Chain calculates popularity, price affinity, freshness, and a normalized semantic score.
• An XGBoost model combines the features into a new business score.
• Milvus returns the reranked results.

One thing worth noting: the final ranking happens inside Milvus, not in FastAPI or the frontend.

This pattern is useful whenever semantic similarity is only the starting point. Product search, for example, may also rank results by rating, popularity, price, and freshness. Instead of retrieving candidates and rebuilding the ranking pipeline in another service, the retrieval layer demos.milvus.io/function-chain… and regithub.com/zc277584121/mi…esult set.

Try it: https://t.co/hoehlDbKFu
Code: https://t.co/yDdf0tIO5f

💬0🔄1❤️6👀414📊1

⚡ Powered by xgo.ing

𝗪𝗲 𝗶𝗻𝘁𝗲𝗴𝗿𝗮𝘁𝗲𝗱 𝗝𝗲𝘃 𝗶𝗻𝘁𝗼 𝘁𝗵𝗿𝗲𝗲 𝗼𝗽𝗲𝗻-𝘀𝗼𝘂𝗿𝗰𝗲 𝗽𝗿𝗼𝗷𝗲𝗰𝘁𝘀 𝘁𝗼 ...

Milvus (@milvusio) — Tue, 22 Sep 2026 19:14:00 GMT

𝗪𝗲 𝗶𝗻𝘁𝗲𝗴𝗿𝗮𝘁𝗲𝗱 𝗝𝗲𝘃 𝗶𝗻𝘁𝗼 𝘁𝗵𝗿𝗲𝗲 𝗼𝗽𝗲𝗻-𝘀𝗼𝘂𝗿𝗰𝗲 𝗽𝗿𝗼𝗷𝗲𝗰𝘁𝘀 𝘁𝗼 𝘁𝗲𝘀𝘁 𝘁𝗵𝗮𝘁 𝗶𝗱𝗲𝗮.

First, in 𝗗𝗲𝗲𝗽𝗦𝗲𝗮𝗿𝗰𝗵𝗲𝗿, we used Jev to decide whether an Agentic Search workflow had gathered enough evidence to stop. Across 100 multi-hop questions, Jev matched DeepSeek V4 Flash at 93.25% Recall@5. Yet median decision latency fell from 2.23s to 0.55s, with estimated API cost at roughly one-seventh.

Second, in 𝗠𝗲𝗺𝗦𝗲𝗮𝗿𝗰𝗵, we tested coding-agent memory reranking on 2,172 private Chinese and English queries. Jev improved Recall@5 from 74.71% to 79.41%, but remained behind the specialist Voyage rerank-3 at 81.87%.

Third, in 𝗩𝗲𝗰𝘁𝗼𝗿 𝗚𝗿𝗮𝗽𝗵 𝗥𝗔𝗚, Jev reranked and filtered candidate relationships for multi-hop retrieval. It outperformed GPT-4o-mini, but trailed GPT-5-mini—by just 1 point on HotpotQA and 4.13 points on the harder MuSiQue benchmark.

Jev is compelling for frequent, bounded judgments such as search stopping, filtering, routing, and simpler reranking.

But as tasks become more domain-specific or reasoning-heavy, stronger generative models and specialist rerankers still earn their place.

Want to digithub.com/zilliztech/dee…
• DeepSearcher — search-stopping experiment, code, and egithub.com/zilliztech/mem…/aqPCKQnhMi
• MemSearch — Jev reranking integration and evaluation: https://t.co/github.com/zilliztech/vec…ph RAG — Jev relationship filtering, evaluation, and cost analysis: https://t.co/7z9kGZsKuO

💬3🔄2❤️14👀1075📊8

⚡ Powered by xgo.ing

𝗖𝗮𝗻 𝗝𝗲𝘃 𝗿𝗲𝗽𝗹𝗮𝗰𝗲 𝗮 𝗿𝗲𝗿𝗮𝗻𝗸𝗲𝗿 𝗶𝗻 𝗥𝗔𝗚? We tested three setups on the same Mi...

Milvus (@milvusio) — Mon, 21 Sep 2026 15:50:00 GMT

𝗖𝗮𝗻 𝗝𝗲𝘃 𝗿𝗲𝗽𝗹𝗮𝗰𝗲 𝗮 𝗿𝗲𝗿𝗮𝗻𝗸𝗲𝗿 𝗶𝗻 𝗥𝗔𝗚?

We tested three setups on the same Milvus shortlist: 𝗻𝗼 𝗿𝗲𝗿𝗮𝗻𝗸𝗶𝗻𝗴, 𝗾𝘄𝗲𝗻𝟯.𝟳-𝘁𝗲𝘅𝘁-𝗿𝗲𝗿𝗮𝗻𝗸, 𝗮𝗻𝗱 𝗝𝗲𝘃.

On 80 SciFact queries, qwen3.7-text-rerank improved nDCG@10 by 𝟬.𝟬𝟰𝟰𝟲 over no reranking, while Jev improved it by 𝟬.𝟬𝟳𝟳𝟴. Jev ranked best of the three, but its P50 reranking latency was 𝟭𝟬.𝟮× 𝗵𝗶𝗴𝗵𝗲𝗿 𝘁𝗵𝗮𝗻 𝗾𝘄𝗲𝗻, with an estimated cost per run of 𝟲.𝟳×.

Why does Jev behave differently?
Its interface is built around 𝘀𝘁𝗮𝘁𝗲 + 𝗾𝘂𝗲𝘀𝘁𝗶𝗼𝗻𝘀. For reranking, we keep the relevance question fixed and change the state for each query-candidate pair: “𝗜𝘀 𝘁𝗵𝗶𝘀 𝗰𝗮𝗻𝗱𝗶𝗱𝗮𝘁𝗲 𝗿𝗲𝗹𝗲𝘃𝗮𝗻𝘁 𝘁𝗼 𝘁𝗵𝗲 𝗾𝘂𝗲𝗿𝘆?” Jev returns a structured Yes/No judgment with probabilities, and we use 𝗣(𝗬𝗲𝘀) as the relevance score for sorting.

In this experiment, 30 candidates meant 30 independent Jev requests running concurrently, so the latency includes that API overhead.

We also tested using probability directly for filtering. At a 𝟬.𝟱 𝘁𝗵𝗿𝗲𝘀𝗵𝗼𝗹𝗱, top-5 precision reached 𝟰𝟵.𝟰%, but 𝟭𝟴.𝟴% 𝗼𝗳 𝗴𝗼𝗹𝗱-𝗿𝗲𝗹𝗲𝘃𝗮𝗻𝘁 𝗱𝗼𝗰𝘂𝗺𝗲𝗻𝘁𝘀 𝘄𝗲𝗿𝗲 𝗳𝗶𝗹𝘁𝗲𝗿𝗲𝗱 𝗼𝘂𝘁. That makes Jev attractive for offline retrieval, data cleaning, and evaluation, but much harder to use as-is for latency-sensitive online RAG.

Next, we’re testing whether batching multiple candidate questions into one Jev request can bring that latency down.

💬11🔄9❤️88👀20859📊39

⚡ Powered by xgo.ing

46K GitHub stars for Milvus! ⭐ Huge thanks to everyone who has contributed code, shared feedback, r...

Milvus (@milvusio) — Fri, 18 Sep 2026 15:42:00 GMT

46K GitHub stars for Milvus! ⭐

Huge thanks to everyone who has contributed code, shared feedback, reported issues, built with Milvus, or helped grow the community. This milestone wouldn’t exist without you.

And while we’re celebrating, here are a few things we’ve been working on lately:

→ 𝗪𝗲 𝗹𝗮𝘂𝗻𝗰𝗵𝗲𝗱 𝗠x.com/zilliz_univers…://t.co/vlA54vjmWl), bringing lake-native vector search and a much more powerful retrieval engine.
→ 𝗪𝗲'𝗿zilliz.com/event/upgrade-…𝗲𝗯𝗶𝗻𝗮𝗿 (https://t.co/xat7IvGAa7) on September 23 about how to upgrade to Milvus 3.0, as well as the availability of Milvus cool features on Zilliz Cloudluma.com/bfo1andh�𝗲𝗮𝗱𝗶𝗻𝗴 𝘁𝗼 𝗣𝗮𝗿𝗶𝘀 🇫🇷  (https://t.co/nUNO3eS9Fb) for our next Milvus Meetup at Criteo on October 7. We’d love to meet more of you there and talk vector search, retrieval, and what it takes to run AI systems at scale.

46K stars is a great reason to celebrate, but we’re even more excited about what we get to build next — togeth#Milvus#OpenSource#VectorDatabaseb#AIInfrastructureus. 💙

#Milvus#OpenSource#VectorDatabase#AIInfrastructure

Zilliz@zilliz_universe

📢 𝗡𝗲𝘄 𝘄𝗲𝗯𝗶𝗻𝗮𝗿: 𝗨𝗽𝗴𝗿𝗮𝗱𝗲 𝘁𝗼 𝗠𝗶𝗹𝘃𝘂𝘀 𝟯.𝟬 — 𝗪𝗵𝗮𝘁’𝘀 𝗡𝗲𝘄 𝗮𝗻𝗱 𝗛𝗼𝘄 𝘁𝗼 𝗚𝗲𝘁 𝗧𝗵𝗲𝗿𝗲

Milvus 3.0 brings new storage formats, indexes, query capabilities, native text deduplication, row-level TTL, and more.

Join 𝗝𝗮𝗲𝗹 𝗚𝘂 𝗮𝗻𝗱 𝗝𝗶𝗮𝗻𝗴 𝗖𝗵𝗲𝗻 for a practical walkthrough of the Milvus 2.6 → 3.0 upgrade.
📅 𝗦𝗲𝗽𝘁𝗲𝗺𝗯𝗲𝗿 𝟮𝟯, 𝟮𝟬𝟮𝟲
�zilliz.com/event/upgrade-… · 𝟭𝟮:𝟬𝟬 𝗣𝗠 𝗖𝗘𝗦𝗧 ·𝟲:𝟬𝟬 𝗣𝗠 𝗦𝗚𝗧
📍 𝟲𝟬 𝗺𝗶𝗻𝘂𝘁𝗲𝘀 · 𝗧𝗮𝗹𝗸 + 𝗟𝗶𝘃𝗲 𝗔𝗠𝗔
🔗 𝗥𝗲𝗴𝗶𝘀𝘁𝗲𝗿: https://t.co/PNmzDKwVpj

𝗪𝗵𝗮𝘁 𝘆𝗼𝘂’𝗹𝗹 𝗹𝗲𝗮𝗿𝗻:
→ What's new in Milvus 3.0 and the value it unlocks
→ How to plan and run the upgrade safely
→ How to verify the result with confidence

Already planning your 2.6 → 3.0 upgrade? Bring your deployment, compatibility, and rollback questions to the live AMA.

🔗 View Quoted Tweet

💬2🔄1❤️5👀637📊2

⚡ Powered by xgo.ing

EverOS from @evermind has 13,000+ GitHub stars and gives AI agents long-term memory across conversat...

Milvus (@milvusio) — Thu, 17 Sep 2026 15:55:00 GMT

EverOS from @evermind has 13,000+ GitHub stars and gives AI agents long-term memory across conversations.

It uses an LLM to extract memories from chats and saves them as Markdown files, so you can inspect what your agent remembers.

Here's how to use Milvus as its search backend.

Install EverOS with its Milvus dependencies, then set EVEROS_INDEX__BACKEND to milvus and EVEROS_MILVUS__URI to your Milvus Server endpoint. EverOS creates and manages the collections for you; you can also connect to Zilliz Cloud using its endpoint and token.

𝗠𝗶𝗹𝘃𝘂𝘀 𝗽𝗿𝗼𝘃𝗶𝗱𝗲𝘀 𝗕𝗠𝟮𝟱 𝗸𝗲𝘆𝘄𝗼𝗿𝗱 𝘀𝗲𝗮𝗿𝗰𝗵 𝗮𝗻𝗱 𝘃𝗲𝗰𝘁𝗼𝗿 𝘀𝗲𝗮𝗿𝗰𝗵 𝗼𝘃𝗲𝗿 𝘁𝗵𝗼𝘀𝗲 𝗺𝗲𝗺𝗼𝗿𝗶𝗲𝘀. EverOS combines the results within the relevant user, application, and project scope to find context for a later conversation.

Markdown stays the source of truth, so the Milvus index can be rebuilt from your memory files.

Our tutorial walks you through the setup and tests retrieval using prmilvus.io/docs/everos_wi…across separate chats.
Try it yourself: https://t.co/J5zdNESa4S

💬1🔄7❤️14👀613📊6

⚡ Powered by xgo.ing

𝟭𝟬𝟬𝗠+ 𝘁𝗿𝗮𝗰𝗸𝘀. 𝗕𝗶𝗹𝗹𝗶𝗼𝗻𝘀 𝗼𝗳 𝘃𝗲𝗰𝘁𝗼𝗿𝘀. ~𝟭𝟬 𝗺𝘀 𝗣𝟵𝟵 𝗱𝗮𝘁𝗮𝗯𝗮𝘀𝗲 ...

Milvus (@milvusio) — Wed, 16 Sep 2026 15:43:00 GMT

𝟭𝟬𝟬𝗠+ 𝘁𝗿𝗮𝗰𝗸𝘀. 𝗕𝗶𝗹𝗹𝗶𝗼𝗻𝘀 𝗼𝗳 𝘃𝗲𝗰𝘁𝗼𝗿𝘀. ~𝟭𝟬 𝗺𝘀 𝗣𝟵𝟵 𝗱𝗮𝘁𝗮𝗯𝗮𝘀𝗲 𝘀𝗲𝗮𝗿𝗰𝗵.

That’s the retrieval scale behind one of the world’s largest music streaming platforms, serving hundreds of millions of listeners across 100+ countries.

Search goes beyond song titles: listeners can 𝗽𝗹𝗮𝘆 𝗮 𝘀𝗵𝗼𝗿𝘁 𝗰𝗹𝗶𝗽, 𝗵𝘂𝗺 𝗮 𝘁𝘂𝗻𝗲, 𝗼𝗿 𝘁𝘆𝗽𝗲 𝗮 𝗵𝗮𝗹𝗳-𝗿𝗲𝗺𝗲𝗺𝗯𝗲𝗿𝗲𝗱 𝗹𝘆𝗿𝗶𝗰. The platform also checks uploaded audio for copyright matches against the full catalog.

To power these experiences, the team built a 𝘀𝗲𝗹𝗳-𝗵𝗼𝘀𝘁𝗲𝗱 𝗠𝗶𝗹𝘃𝘂𝘀 𝗿𝗲𝘁𝗿𝗶𝗲𝘃𝗮𝗹 𝗹𝗮𝘆𝗲𝗿 spanning audio and lyrics.

Each song becomes multiple short audio vectors, pushing the system to billions of vectors across the catalog. Lyrics combine semantic and full-text search, with filters for territory and rights.

The result:
-> 𝟭𝟬𝟬𝗠+ 𝘁𝗿𝗮𝗰𝗸𝘀 searchable across the full catalog
-> ~𝟭𝟬 𝗺𝘀 𝗣𝟵𝟵 database search latency at hundreds of searches per second
-> One infrastructure serves for 𝘀𝗼𝗻𝗴 𝗿𝗲𝗰𝗼𝗴𝗻𝗶𝘁𝗶𝗼𝗻, 𝗹𝘆𝗿𝗶𝗰 𝘀𝗲𝗮𝗿𝗰𝗵, 𝗿𝗲𝗰𝗼𝗺𝗺𝗲𝗻𝗱𝗮𝘁𝗶zilliz.com/customers/musi…𝗿𝗶𝗴𝗵𝘁 𝗺𝗮𝘁𝗰𝗵𝗶𝗻𝗴

𝗔𝘁 𝘁𝗵𝗶𝘀 𝘀𝗰𝗮𝗹𝗲, 𝘃𝗲𝗰𝘁𝗼𝗿 𝘀𝗲𝗮𝗿𝗰𝗵 𝗶𝘀𝗻’𝘁 𝗷𝘂𝘀𝘁 𝗮 𝗳𝗲𝗮𝘁𝘂𝗿𝗲 𝗯𝗲𝗵𝗶𝗻𝗱 𝗺𝘂𝘀𝗶𝗰 𝗱𝗶𝘀𝗰𝗼𝘃𝗲𝗿𝘆 — 𝗶𝘁’𝘀 𝗰𝗼𝗿𝗲 𝘀𝗲𝗮𝗿𝗰𝗵 𝗶𝗻𝗳𝗿𝗮𝘀𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲.

See how the platform built it with Milvus:
https://t.co/f9vsUJWHcE

💬1🔄0❤️0👀231📊1

⚡ Powered by xgo.ing

Milvus (@milvusio) — Wed, 16 Sep 2026 15:43:00 GMT

💬1🔄0❤️0👀110📊1

⚡ Powered by xgo.ing

Milvus (@milvusio) — Wed, 16 Sep 2026 15:43:00 GMT

💬0🔄0❤️0👀70

⚡ Powered by xgo.ing

Agent memory gets messy as project knowledge piles up, and the real challenge is making sure the rig...

Milvus (@milvusio) — Mon, 14 Sep 2026 15:52:00 GMT

Agent memory gets messy as project knowledge piles up, and the real challenge is making sure the right piece comes back at the right time.

That’s where 𝗠𝗲𝗺𝗣𝗮𝗹𝗮𝗰𝗲 comes in. It organizes project knowledge like a palace:
• A wing holds a project or knowledge base.
• Rooms group related topics.
• Drawers keep the original content in smaller, searchable pieces.

Milvus works behind the scenes, storing the text, embeddings, and metadata that make those drawers searchable.

In our tutorial, we build a memory palace from 31 pages of the Milvus Analyzer docs. MemPalace sorts them into Analyzer, Filter, and Tokenizer rooms, breaks them into 473 chunks, creates embeddings locally, and stores everything in Milvus Lite.

The whole example runs on your laptop, with no Docker or external model API key required.

Once the content is indexed, you can ask, “How should I analyze documents that mix several languages?” and retrieve the relevant source text without knowing the exact page or wording.

Want to give your coding agent a better way to organize and retrieve project knowledge?

Follow our tutorial and build your own memorymilvus.io/docs/mempalace…hwCS6Oy13

💬1🔄2❤️7👀326📊4

⚡ Powered by xgo.ing

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

💬5🔄4❤️7👀525📊8

⚡ 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👀220

⚡ 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👀210

⚡ 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❤️11👀6409📊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👀1055📊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👀341

⚡ 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👀593📊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👀224📊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👀277📊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👀254📊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👀444📊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👀514📊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👀229📊1

⚡ Powered by xgo.ing

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

💬1🔄0❤️0👀106📊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👀641📊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👀863📊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👀238

⚡ 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