Milvus 查询引擎剖析：从 SQL 到向量检索的执行全流程

“

一条查询请求如何在 Milvus 中执行？本文将深入查询引擎的内部，揭示向量检索的完整流程。

全文约 6000 字，建议阅读时间 15 分钟

一、查询引擎概览

1.1 查询类型

Milvus 支持三种主要查询类型：

from pymilvus import Collection

collection = Collection("documents")

# 1. 向量搜索（ANN Search）
results = collection.search(
    data=[[0.1] * 768],  # 查询向量
    anns_field="embedding",
    param={"metric_type": "COSINE", "params": {"ef": 64}},
    limit=10
)

# 2. 标量查询（Query）
results = collection.query(
    expr="score > 0.8 and category == 'tech'",
    output_fields=["id", "text", "score"]
)

# 3. 混合查询（Hybrid Search）
results = collection.hybrid_search(
    reqs=[
        # 向量搜索
        AnnSearchRequest(
            data=[[0.1] * 768],
            anns_field="dense_vector",
            param={"metric_type": "COSINE"},
            limit=10
        ),
        # 全文检索
        AnnSearchRequest(
            data=[[0.2] * 1000],
            anns_field="sparse_vector",
            param={"metric_type": "IP"},
            limit=10
        )
    ],
    rerank=WeightedRanker(0.7, 0.3),  # 重排序
    limit=10
)

1.2 查询架构

查询执行流程：

┌─────────┐
│ Client  │ 发起查询
└────┬────┘
     │
┌────▼────┐
│  Proxy  │ 1. 解析请求
└────┬────┘ 2. 查询路由
     │      3. 负载均衡
     │
     ├──────────────────┬──────────────────┐
     │                  │                  │
┌────▼────┐        ┌───▼────┐        ┌───▼────┐
│QueryNode│        │QueryNode│        │QueryNode│
│  Node1  │        │  Node2  │        │  Node3  │
└────┬────┘        └───┬────┘        └───┬────┘
     │                 │                  │
     │ 1. 标量过滤      │                  │
     │ 2. 向量检索      │                  │
     │ 3. 返回 TopK     │                  │
     │                 │                  │
     └─────────────────┴──────────────────┘
                       │
┌──────────────────────▼────┐
│  Proxy                     │
│  1. 合并结果                │
│  2. 全局排序                │
│  3. 返回最终 TopK           │
└────────────────────────────┘

二、查询解析与规划

2.1 表达式解析

Milvus 支持类 SQL 的表达式语法：

# 基础表达式
expr = "id in [1, 2, 3]"
expr = "score > 0.8"
expr = "category == 'tech'"

# 复合表达式
expr = "score > 0.8 and category == 'tech'"
expr = "(score > 0.8 or views > 1000) and category != 'spam'"

# 数组操作
expr = "tags array_contains 'AI'"
expr = "tags array_contains_any ['AI', 'ML']"
expr = "tags array_contains_all ['AI', 'ML', 'DL']"

# JSON 字段
expr = "metadata['author'] == 'Alice'"
expr = "metadata['tags'][0] == 'featured'"

# 字符串操作
expr = "text like 'Milvus%'"# 前缀匹配
expr = "text like '%database%'"# 包含匹配

表达式 AST（抽象语法树）：

// 表达式解析器
type ExprParser struct {
    lexer  *Lexer
    tokens []Token
}

// 解析表达式
func (p *ExprParser) Parse(expr string) (*ExprNode, error) {
    // 1. 词法分析
    tokens := p.lexer.Tokenize(expr)
    
    // 2. 语法分析，构建 AST
    ast := p.buildAST(tokens)
    
    // 3. 语义分析，类型检查
    if err := p.validate(ast); err != nil {
        returnnil, err
    }
    
    return ast, nil
}

// AST 节点
type ExprNode struct {
    Type     NodeType  // AND, OR, EQ, GT, LT, IN, etc.
    Left     *ExprNode
    Right    *ExprNode
    Value    interface{}
    FieldID  int64
}

// 示例：score > 0.8 and category == 'tech'
// AST:
//       AND
//      /   \
//     GT    EQ
//    / \   / \
// score 0.8 category 'tech'

2.2 查询计划生成

// 查询计划器
type QueryPlanner struct {
    schema *Schema
    stats  *Statistics
}

// 生成查询计划
func (qp *QueryPlanner) Plan(req *SearchRequest) (*QueryPlan, error) {
    plan := &QueryPlan{}
    
    // 1. 解析表达式
    if req.Expr != "" {
        exprNode, err := qp.parseExpr(req.Expr)
        if err != nil {
            returnnil, err
        }
        plan.FilterNode = exprNode
    }
    
    // 2. 选择索引
    plan.VectorIndex = qp.selectVectorIndex(req.AnnsField)
    plan.ScalarIndexes = qp.selectScalarIndexes(plan.FilterNode)
    
    // 3. 估算成本
    plan.Cost = qp.estimateCost(plan)
    
    // 4. 优化计划
    plan = qp.optimize(plan)
    
    return plan, nil
}

// 查询计划
type QueryPlan struct {
    // 过滤条件
    FilterNode *ExprNode
    
    // 向量检索
    VectorIndex  *IndexInfo
    VectorField  string
    MetricType   string
    SearchParams map[string]interface{}
    
    // 标量索引
    ScalarIndexes []*IndexInfo
    
    // 执行顺序
    ExecutionOrder []PlanNode
    
    // 成本估算
    Cost float64
}

2.3 查询优化

优化 1：谓词下推（Predicate Pushdown）

// 将过滤条件尽早应用，减少数据量
func (qp *QueryPlanner) pushDownPredicate(plan *QueryPlan) {
    // 原始计划：
    // 1. 向量检索 → 10000 个结果
    // 2. 标量过滤 → 100 个结果
    
    // 优化后：
    // 1. 标量过滤 → 1000 个候选
    // 2. 向量检索 → 100 个结果
    
    if plan.FilterNode != nil && qp.hasScalarIndex(plan.FilterNode) {
        // 先执行标量过滤
        plan.ExecutionOrder = []PlanNode{
            &ScalarFilterNode{Expr: plan.FilterNode},
            &VectorSearchNode{...},
        }
    }
}

优化 2：索引选择

// 选择最优索引
func (qp *QueryPlanner) selectBestIndex(expr *ExprNode) *IndexInfo {
    candidates := qp.findApplicableIndexes(expr)
    
    // 评估每个索引的成本
    bestIndex := candidates[0]
    minCost := qp.estimateIndexCost(bestIndex, expr)
    
    for _, idx := range candidates[1:] {
        cost := qp.estimateIndexCost(idx, expr)
        if cost < minCost {
            minCost = cost
            bestIndex = idx
        }
    }
    
    return bestIndex
}

优化 3：并行执行

// 并行执行多个 Segment 的查询
func (qn *QueryNode) parallelSearch(plan *QueryPlan) []*SearchResult {
    segments := qn.getSegments(plan.CollectionID)
    
    // 创建工作池
    numWorkers := runtime.NuMCPU()
    jobs := make(chan *Segment, len(segments))
    results := make(chan *SearchResult, len(segments))
    
    // 启动 worker
    for i := 0; i < numWorkers; i++ {
        gofunc() {
            for seg := range jobs {
                result := qn.searchSegment(seg, plan)
                results <- result
            }
        }()
    }
    
    // 分发任务
    for _, seg := range segments {
        jobs <- seg
    }
    close(jobs)
    
    // 收集结果
    allResults := make([]*SearchResult, 0, len(segments))
    for i := 0; i < len(segments); i++ {
        allResults = append(allResults, <-results)
    }
    
    return allResults
}

三、向量检索执行

3.1 Segment 内检索

// Segment 的向量检索
func (seg *Segment) Search(query []float32, topK int, filter *Bitset) *SearchResult {
    // 1. 应用标量过滤（生成 Bitset）
    bitset := seg.applyFilter(filter)
    
    // 2. 向量检索
    var result *SearchResult
    if seg.hasIndex() {
        // 使用索引检索
        result = seg.index.Search(query, topK, bitset)
    } else {
        // 暴力搜索
        result = seg.bruteForceSearch(query, topK, bitset)
    }
    
    // 3. 应用删除过滤
    result = seg.filterDeleted(result)
    
    return result
}

// HNSW 索引检索
func (idx *HNSWIndex) Search(query []float32, k int, bitset *Bitset) *SearchResult {
    // 1. 从入口点开始
    ep := idx.entryPoint
    
    // 2. 逐层贪心搜索
    for level := idx.maxLevel; level > 0; level-- {
        ep = idx.searchLayer(query, ep, 1, level, bitset)
    }
    
    // 3. 在第 0 层精确搜索
    candidates := idx.searchLayer(query, ep, idx.ef, 0, bitset)
    
    // 4. 返回 TopK
    return candidates.TopK(k)
}

// 搜索层
func (idx *HNSWIndex) searchLayer(
    query []float32,
    entryPoint *Node,
    numClosest int,
    layer int,
    bitset *Bitset,
) []*Candidate {
    visited := make(map[int64]bool)
    candidates := NewMinHeap()
    results := NewMaxHeap()
    
    // 初始化
    dist := idx.distance(query, entryPoint.Vector)
    candidates.Push(&Candidate{Node: entryPoint, Distance: dist})
    results.Push(&Candidate{Node: entryPoint, Distance: dist})
    visited[entryPoint.ID] = true
    
    // 贪心搜索
    for candidates.Len() > 0 {
        current := candidates.Pop()
        
        // 如果当前点比结果中最远的点还远，停止
        if current.Distance > results.Top().Distance {
            break
        }
        
        // 扩展邻居
        for _, neighbor := range current.Node.Neighbors[layer] {
            if visited[neighbor.ID] {
                continue
            }
            visited[neighbor.ID] = true
            
            // 应用 Bitset 过滤
            if bitset != nil && !bitset.Test(neighbor.ID) {
                continue
            }
            
            dist := idx.distance(query, neighbor.Vector)
            
            if dist < results.Top().Distance || results.Len() < numClosest {
                candidates.Push(&Candidate{Node: neighbor, Distance: dist})
                results.Push(&Candidate{Node: neighbor, Distance: dist})
                
                if results.Len() > numClosest {
                    results.Pop()
                }
            }
        }
    }
    
    return results.ToSlice()
}

3.2 标量过滤

// 标量过滤器
type ScalarFilter struct {
    expr   *ExprNode
    schema *Schema
}

// 生成 Bitset
func (sf *ScalarFilter) Filter(segment *Segment) *Bitset {
    bitset := NewBitset(segment.NumRows)
    
    // 遍历所有行
    for rowID := 0; rowID < segment.NumRows; rowID++ {
        if sf.evaluate(segment, rowID) {
            bitset.Set(rowID)
        }
    }
    
    return bitset
}

// 评估表达式
func (sf *ScalarFilter) evaluate(segment *Segment, rowID int) bool {
    return sf.evaluateNode(sf.expr, segment, rowID)
}

func (sf *ScalarFilter) evaluateNode(node *ExprNode, segment *Segment, rowID int) bool {
    switch node.Type {
    case NodeType_AND:
        return sf.evaluateNode(node.Left, segment, rowID) &&
               sf.evaluateNode(node.Right, segment, rowID)
    
    case NodeType_OR:
        return sf.evaluateNode(node.Left, segment, rowID) ||
               sf.evaluateNode(node.Right, segment, rowID)
    
    case NodeType_EQ:
        fieldValue := segment.GetFieldValue(node.FieldID, rowID)
        return fieldValue == node.Value
    
    case NodeType_GT:
        fieldValue := segment.GetFieldValue(node.FieldID, rowID)
        return fieldValue.(float64) > node.Value.(float64)
    
    case NodeType_IN:
        fieldValue := segment.GetFieldValue(node.FieldID, rowID)
        values := node.Value.([]interface{})
        for _, v := range values {
            if fieldValue == v {
                returntrue
            }
        }
        returnfalse
    
    default:
        returnfalse
    }
}

3.3 距离计算优化

// SIMD 优化的距离计算
import"golang.org/x/sys/cpu"

// L2 距离（欧氏距离）
func L2Distance(a, b []float32) float32 {
    if cpu.X86.HasAVX2 {
        return l2DistanceAVX2(a, b)
    }
    return l2DistanceScalar(a, b)
}

// AVX2 优化版本
func l2DistanceAVX2(a, b []float32) float32 {
    // 使用 AVX2 指令集，一次处理 8 个 float32
    // 性能提升 4-8 倍
    var sum float32
    // ... AVX2 实现
    return sum
}

// 标量版本
func l2DistanceScalar(a, b []float32) float32 {
    var sum float32
    for i := range a {
        diff := a[i] - b[i]
        sum += diff * diff
    }
    return sum
}

// 余弦相似度
func CosineSimilarity(a, b []float32) float32 {
    var dotProduct, normA, normB float32
    
    for i := range a {
        dotProduct += a[i] * b[i]
        normA += a[i] * a[i]
        normB += b[i] * b[i]
    }
    
    return dotProduct / (sqrt(normA) * sqrt(normB))
}

// 内积
func InnerProduct(a, b []float32) float32 {
    var sum float32
    for i := range a {
        sum += a[i] * b[i]
    }
    return sum
}

四、结果聚合与排序

4.1 多 Segment 结果合并

// Proxy 的结果聚合
func (p *Proxy) mergeResults(results []*SearchResult, topK int) *SearchResult {
    // 1. 使用最小堆合并多个有序列表
    heap := NewMinHeap()
    
    // 2. 初始化：每个结果的第一个元素入堆
    for i, result := range results {
        iflen(result.IDs) > 0 {
            heap.Push(&HeapNode{
                Distance:  result.Distances[0],
                ID:        result.IDs[0],
                ResultIdx: i,
                ItemIdx:   0,
            })
        }
    }
    
    // 3. 归并排序
    merged := &SearchResult{
        IDs:       make([]int64, 0, topK),
        Distances: make([]float32, 0, topK),
    }
    
    for heap.Len() > 0 && len(merged.IDs) < topK {
        node := heap.Pop()
        
        // 去重（同一个 ID 可能在多个 Segment 中）
        if !merged.Contains(node.ID) {
            merged.IDs = append(merged.IDs, node.ID)
            merged.Distances = append(merged.Distances, node.Distance)
        }
        
        // 将该结果的下一个元素入堆
        result := results[node.ResultIdx]
        nextIdx := node.ItemIdx + 1
        if nextIdx < len(result.IDs) {
            heap.Push(&HeapNode{
                Distance:  result.Distances[nextIdx],
                ID:        result.IDs[nextIdx],
                ResultIdx: node.ResultIdx,
                ItemIdx:   nextIdx,
            })
        }
    }
    
    return merged
}

4.2 分布式结果聚合

// 多 QueryNode 结果聚合
func (p *Proxy) aggregateFromNodes(nodeResults map[int64]*SearchResult, topK int) *SearchResult {
    // 1. 收集所有结果
    allResults := make([]*SearchResult, 0, len(nodeResults))
    for _, result := range nodeResults {
        allResults = append(allResults, result)
    }
    
    // 2. 合并结果
    merged := p.mergeResults(allResults, topK)
    
    // 3. 填充其他字段（如果需要）
    iflen(p.outputFields) > 0 {
        merged = p.fillOutputFields(merged)
    }
    
    return merged
}

// 填充输出字段
func (p *Proxy) fillOutputFields(result *SearchResult) *SearchResult {
    // 批量查询其他字段
    ids := result.IDs
    fields := p.queryFieldsByIDs(ids, p.outputFields)
    
    result.Fields = fields
    return result
}

4.3 重排序（Reranking）

from pymilvus import Collection, AnnSearchRequest, RRFRanker

collection = Collection("documents")

# 多路召回 + 重排序
req1 = AnnSearchRequest(
    data=[[0.1] * 768],
    anns_field="dense_vector",
    param={"metric_type": "COSINE"},
    limit=100# 召回 100 个
)

req2 = AnnSearchRequest(
    data=[[0.2] * 1000],
    anns_field="sparse_vector",
    param={"metric_type": "IP"},
    limit=100# 召回 100 个
)

# RRF（Reciprocal Rank Fusion）重排序
results = collection.hybrid_search(
    reqs=[req1, req2],
    rerank=RRFRanker(k=60),  # RRF 参数
    limit=10# 最终返回 10 个
)

RRF 算法：

// RRF 重排序
func RRFRerank(results [][]*SearchResult, k int) []*SearchResult {
    // RRF 公式：score(d) = Σ 1 / (k + rank_i(d))
    scores := make(map[int64]float64)
    
    for _, resultList := range results {
        for rank, result := range resultList {
            scores[result.ID] += 1.0 / float64(k + rank + 1)
        }
    }
    
    // 按分数排序
    ranked := make([]*SearchResult, 0, len(scores))
    for id, score := range scores {
        ranked = append(ranked, &SearchResult{
            ID:    id,
            Score: score,
        })
    }
    
    sort.Slice(ranked, func(i, j int) bool {
        return ranked[i].Score > ranked[j].Score
    })
    
    return ranked
}

五、查询性能优化

5.1 缓存策略

// QueryNode 的缓存
type QueryNodeCache struct {
    // Segment 缓存
    segmentCache *LRUCache
    
    // 查询结果缓存
    resultCache *LRUCache
    
    // 向量缓存
    vectorCache *LRUCache
}

// 查询时先检查缓存
func (qn *QueryNode) searchWithCache(req *SearchRequest) *SearchResult {
    // 1. 生成缓存 key
    cacheKey := qn.generateCacheKey(req)
    
    // 2. 检查结果缓存
    if cached, ok := qn.cache.resultCache.Get(cacheKey); ok {
        return cached.(*SearchResult)
    }
    
    // 3. 执行查询
    result := qn.search(req)
    
    // 4. 缓存结果
    qn.cache.resultCache.Put(cacheKey, result)
    
    return result
}

5.2 预取（Prefetch）

// 预取下一批 Segment
func (qn *QueryNode) prefetchSegments(currentSegmentID int64) {
    // 预测下一个可能访问的 Segment
    nextSegments := qn.predictNextSegments(currentSegmentID)
    
    // 异步加载
    for _, segID := range nextSegments {
        go func(id int64) {
            qn.loadSegment(id)
        }(segID)
    }
}

5.3 批量查询

# 单条查询（慢）
for query in queries:
    result = collection.search(data=[query], ...)

# 批量查询（快 10 倍）
batch_size = 100
for i in range(0, len(queries), batch_size):
    batch = queries[i:i+batch_size]
    results = collection.search(data=batch, ...)

5.4 分区裁剪

# 不指定分区（扫描所有分区）
results = collection.search(
    data=[query_vector],
    anns_field="embedding",
    limit=10
)

# 指定分区（只扫描相关分区）
results = collection.search(
    data=[query_vector],
    anns_field="embedding",
    partition_names=["2024_11"],  # 只搜索 11 月的数据
    limit=10
)

六、实战案例

6.1 复杂查询示例

from pymilvus import Collection

collection = Collection("products")

# 复杂过滤 + 向量搜索
results = collection.search(
    data=[[0.1] * 768],
    anns_field="image_embedding",
    param={"metric_type": "L2", "params": {"nprobe": 32}},
    limit=20,
    expr="""
        (price >= 100 and price <= 500) and
        category in ['electronics', 'computers'] and
        rating > 4.0 and
        stock > 0 and
        tags array_contains_any ['featured', 'bestseller']
    """,
    output_fields=["name", "price", "rating", "image_url"]
)

# 处理结果
for hit in results[0]:
    print(f"Product: {hit.entity.get('name')}")
    print(f"Price: ${hit.entity.get('price')}")
    print(f"Rating: {hit.entity.get('rating')}")
    print(f"Distance: {hit.distance}")
    print("---")

6.2 分页查询

# 第一页
page_size = 20
results_page1 = collection.search(
    data=[query_vector],
    anns_field="embedding",
    limit=page_size,
    offset=0
)

# 第二页
results_page2 = collection.search(
    data=[query_vector],
    anns_field="embedding",
    limit=page_size,
    offset=page_size
)

6.3 范围查询

# 查找距离在 [0.5, 1.0] 范围内的向量
results = collection.search(
    data=[query_vector],
    anns_field="embedding",
    param={
        "metric_type": "L2",
        "params": {"nprobe": 32},
        "radius": 1.0,      # 最大距离
        "range_filter": 0.5  # 最小距离
    },
    limit=100
)

七、总结

核心要点

1. 查询类型：向量搜索、标量查询、混合查询
2. 查询优化：谓词下推、索引选择、并行执行
3. 向量检索：HNSW 图搜索、SIMD 加速
4. 结果聚合：多 Segment 合并、分布式聚合、重排序
5. 性能优化：缓存、预取、批量查询、分区裁剪

最佳实践

✅ 使用表达式过滤减少搜索空间 ✅ 批量查询提升吞吐量 ✅ 合理设置 TopK 和搜索参数 ✅ 利用分区裁剪加速查询 ✅ 使用混合搜索提高召回率

关注云与数字化，一起探索向量数据库的技术奥秘！

如果觉得文章有帮助，欢迎点赞、转发、收藏！

参考资料

• Milvus 查询文档：https://milvus.io/docs/search.md
• HNSW 论文：Efficient and robust approximate nearest neighbor search
• 查询优化论文：Query Optimization in Database Systems

标签：#Milvus #查询引擎 #向量检索 #查询优化 #HNSW

• 深入 ServiceNow AI Experience：AI 如何重新定义运维工作流
  

• AI 治理的下一站：从“可解释”到“可信赖”——ServiceNow Guardian 启示录
  

• 从工单驱动到智能闭环：AI 自主智能体在企业 ITSM 的落地路径
  

• AI 驱动的自治运维架构：从 ServiceNow “AI 成熟度指数 2025” 到企业落地实战
  

• 用 LangGraph 实现 Stateful Routing：让 LLM 拥有上下文感知的智能路由能力
  

• Agents 2025 全景解读：从单兵工具到企业级协作体" data-itemshowtype="0" linktype="text" data-linktype="2">AI Agents 2025 全景解读：从单兵工具到企业级协作体
  

• AI 芯片国产化冲击下，企业 IT 基础设施架构的五大适应策略
  

• Vibe Coding：AI 主导下的下一个编程范式
  

• 从“看得见”到“能决策”：Operation Intelligence 重构企业智能运维新范式
  

• 分布式 Multi Agent 安全高可用探索与实践
  

• SRE 的夜晚，不再孤独：AI 如何守护我们的系统？
  

• 构建企业级 Workflow Agent 架构：LangGraph 与 MCP 实战
  

• Workflow Agent 实战：LangGraph + MCP 架构下的企业智能流转系统
  

• AI-Native 企业架构：从流程自动化到智能决策中枢
  

• 计算机视觉图像增广实战：用 PyTorch 与 Albumentations 打造高鲁棒性模型
  

• 当 AI 成为企业的神经系统：Workflow OS 的未来
  

• 基于 Spring AI Alibaba + Nacos 的分布式 Multi-Agent 构建指南
  

• Claude SDK vs LangGraph：Agent 架构差异与协同模式
  

• DeepSeek OCR：学习理解" data-itemshowtype="0" linktype="text" data-linktype="2">DeepSeek OCR：学习理解
  

• Prompt Engineering 快速入门+实战案例
  

• 意图识别的技术演进与工程实战：从NLP到智能Agent
  

• LLM + Prometheus 构建智能观测中枢：迈向智能化平台工程的演进路径
  

• 用 AI 构建 ITSM Copilot：从前端流程到智能表单交互（实战详解）
  

• 用 AI 重构 DevOps 工单流程：从响应到闭环的智能化革命
  

• 企业AI落地实践（三）：使用 AI 网关解决 AI Agent 与 LLM 的交互挑战
  

• 用 Agent + RAG 攻克垂直行业难题：AI 商业化的真正出路
  

• 智能涌现：AI 代理与智能 AI 系统的战略演进与落地之路
  

• 用微前端构建 AI 增强的前端产品工厂：打造“多团队、多产品、多租户”平台体系
  

• 用 LLM 辅助开发 Linux 内核模块：从 Device Driver 到 Netfilter
  

• 【深度】企业 AI 落地实践（四）：如何构建端到端的 AI 应用观测体系
  

• 超越基础：Agentic Chunking 如何彻底改变 RAG？

• AI Agent 如何支撑治理结构：从应用组合到服务投资组合管理

• ServiceNow 多 Agent 系统中的知识共享与记忆机制设计

• ServiceNow AI Agent 多 Agent 协作架构与通信机制设计（第二部分）

• ServiceNow AI Agent 多 Agent 协作架构与通信机制设计
  

• dify Agent 和 Semantic Kernel 的智能运维系统：从告警到自动修复" data-itemshowtype="0" linktype="text" data-linktype="2">构建基于 Dify Agent 和 Semantic Kernel 的智能运维系统：从告警到自动修复
  

• Semantic Kernel 与 LangChain 比较：探索智能决策与大语言模型的协同作用
  

• 构建企业级多智能体系统：AutoGen + Semantic Kernel 实践指南
  

• 用 CrewAI 构建团队 Agent 系统，角色协同完成 RAG 任务
  

• 张量的力量：PyTorch 中的 Tensor 操作秘籍
  

• AI Agent 工具盘点：AutoGPT、CrewAI、LangGraph、AgentVerse 谁更适合 DevOps？
  

• AI 驱动的运维 - 实体识别方法与提示词 (基于 DeepSeek API 和 Dify)
  

• 基于 LangChain 和 Confluence 构建 AI Agent
  

• 学习如何优化LLM训练：数据预处理与实战策略解析
  

• Building Langchain MCP Client with Python
  

• Manus - 面向 Java 开发者的开源通用智能体" data-itemshowtype="11" linktype="text" data-linktype="2">JManus - 面向 Java 开发者的开源通用智能体
  

• 基于AutoGen的多Agent系统架构设计与工程实践
  

• 从规则到Transformer：自然语言处理的演进与变革
  

• 深入理解哈达玛积：从零开始掌握深度学习中的关键操作
  

• MCP Server 实践之旅第 3 站：MCP 协议亲和性的技术内幕
  

• 来自分析师的洞察：一体化数据库成为 GenAI 时代的数据底座
  

• Spring AI Alibaba + Nacos 动态 MCP Server 代理方案
  

• 智领未来：Semantic Kernel 智能体框架如何重塑智能 DevOps 自动化
  

• Qwen2 开源全解读：部署、微调与工程实践
  

• 从零开始开发 MCP Server
  

• 顶会论文解读
  

• MCP Server 实践之旅第 1 站：MCP 协议解析与云上适配
  

• Semantic Kernel 与 LangChain 比较：探索智能决策与大语言模型的协同作用
  

• MCP 规范新版本特性全景解析与落地实践
  

• 小白也能看懂的 MCP 介绍
  

• 构建企业级多智能体系统：AutoGen + Semantic Kernel 实践指南
  

• 利用自一致性策略与多路径推理，打造下一代 AI 驱动的智能 SRE 系统
  

• 深入学习 BERT论文
  

• GGUF 深度学习与应用：本地运行 AI 模型的新标准
  

• LangGraph Agents
  

• RAG实践：探索如何在Colab 上构建 RAG 模型：结合 LlamaIndex 与 HuggingFace
  

• Open-Source-AI-Stack
  

• 如何用 Jenkins、OpenAI 和 Conda 打造高效的自动化开发环境？
  

• RAG 调优指南：Spring AI Alibaba 模块化 RAG 原理与使用
  

• 新手村教程！用Pandas玩转机器学习中的线性代数

• 小白也能懂！用Pandas学线性代数核心概念

• FlashMLA开源推理框架解析：专为LLM优化的高性能引擎

• NVIDIA Hopper架构解析：重新定义AI与超算的硬件基石

• 深入掌握 Pandas 的 iloc 方法：基于位置的精准数据索引

• 基于 PyTorch 和 DeepSeek R1 训练智能告警预测模型

• 使用 pd.get_dummies 进行独热编码：从入门到实践
  

• 人工智能|VLLM：解锁大模型推理的终极神器，效率提升10倍！
  

• 人工智能|VLLM 技术解析：大模型推理性能优化的工程实践
  

• 巧用通义灵码，提升前端研发效率
  

• 保姆级教程！DeepSeek+Chatbox 10分钟教会你实现AI客户端应用和智能助手
  

• 人工智能|梯度校验与高级优化
  

• 人工智能|机器学习：解锁智能时代的密码
  

• 人工智能|反向传播算法
  

• 人工智能|模型蒸馏

• 人工智能 |春节入门学习神经网络的基础知识

• 学习笔记：向量、向量数据库与强化学习

• 人工智能：提示词实践在运维（SRE/DevOps）领域的应用
  

• 提示词生成工具与框架：帮助你提升AI应用的效率与质量

• 从人工到自动化到AIOps再到ChatOps：大模型在运维领域的应用

• 人工智能｜数据挖掘学习总结：关联分析与Apriori算法

• 《月狐报告 | AI 产业全景洞察报告 2025》学习

• 人工智能｜学习笔记：从余弦到向量数据库

• 如何利用AI进行“微调”提升模型表现？从三年级数学到各类应用场景的实践
  

• 人工智能|春节阅读DeepSeek-R1 发布，性能对标 OpenAI o1 正式版
  

• 打造AI之核心：特征工程的艺术与技巧
  

• 人工智能｜OpenCV-Python
  

• 人工智能｜视频识别
  

• 人工智能｜chatGPT原理理解01
  

• 人工智能｜Training large language models on Amazon SageMaker
  

• 人工智能｜What is LSTM?
  

• 人工智能｜数学基础｜回归分析理论
  

• 《深度学习入门二》人工“碳”索意犹尽，智能“硅”来未可知
  

• 人工智能:深度学习入门一
  

• 机器学习｜简单线性回归
  

• 机器学习｜Generative AI
  

• 机器学习｜cost function 学习
  

• 机器学习｜学习率
  

• 机器学习｜房价预测案例学习｜sklearn.linear_model LinearRegression
  

• 机器学习｜数学基础矩阵，逆矩阵，向量空间，线性变换
  

• 机器学习｜数学基础之概率统计基础
  

• 机器学习｜相关数学基础理论
  

• 机器学习｜聚类分析
  

• 机器学习｜从Prometheus数据中学习
  

• 机器学习｜深度学习认识
  

• 机器学习一些概念理解
  

• 机器学习｜系统搭建的流程
  

• 机器学习概述学习
  

• 机器学习｜XGBoost算法解析
  

• 机器学习：贝叶斯定理学习
  

• 机器学习决策树的分裂到底是什么？这篇文章讲明白了！
  

• 机器学习从统计学习开始
  

• 机器学习的两次浪潮

• 人工智能：提示词实践在运维（SRE/DevOps）领域的应用

• 智能化转型：提高业务效率的人工智能代理类型

• 探索未来科技：计算机科学、人工智能、微电子学与自动化控制的交叉与融合

• 拥抱人工智能驱动的产业智能革命：从IT硬件到数据核心资产的演变

• 感知器：人工智能发展的里程碑

• 人工智能｜人工智能领域知名的论文

• 人工智能｜从GPU到PyTorch 训练入门

• 人工智能｜打造你自己的ChatGPT：从数据到部署的完整指南

• 人工智能，github有哪些开源的知名的人工智能项目

• 人工智能，开源的大模型有哪些

• 人工智能，体验 TensorRT 加速 Stable Diffusion 图像创作

基于身份的网络安全：Cilium策略执行机制

深入理解Cilium eBPF数据平面架构

Cilium 首次集成国内云服务，阿里云 ENI 被纳入新版本特性

Cilium连接跟踪机制深度解析：网络状态管理的基础

Cilium隧道网络实现深度解析：多集群部署的核心

• mysql，阅读mysql-8.0.27/storage/innobase/include/api0api.h头文件
  

• ODC解读：数据脱敏在数据库协同开发的关键作用

• Mongo数据库的一些聚合函数用法

• 构建高效数据流转的 ETL 系统：数据库 + Serverless 函数计算的最佳实践

• 国产数据库OceanBase 4.2特性解读：Show Trace全链路跟踪，助力快速问题定位与精准诊断
  

• 数据库，MySQL从服务器指令

• 数据库，MySQL8.0创建用户与之前版本的区别

• 数据库，MySQL的复制

• 深入探讨 MySQL：性能模式中的内存管理分析

• MySQL 实例摘要

• MySQL Percona Monitoring and Management

• mysql LOCK ORDER了解

• MySQL InnoDB 中next-key locking 算法理解

• 高性能MySQL实战（二）：索引

• 高性能MySQL实战（一）：表结构

• MySQL | InnoDB存储的数据结构如何组织的

• MySQL | InnoDB是如何存储数据

• Elasticsearch|8.8.1-mysql日志收集实验

• 数据库｜MySQL优化器初步了解

• 数据库｜mysql-8.0.27 源代码入口函数

• 数据库｜mysql Using temporary 与 Using filesort

• Hikari Configuration for MySQL in Spring Boot 2

• 数据库｜MySQL innodb 行记录存储学习

• MySQL字符集学习

• MySQL主备模式的数据一致性解决方案

• 统一观测丨使用 Prometheus 监控 MySQL

• 数据库｜MYSQL-INNODB索引构成详解

• 从一条SQL了解MYSQL的架构设计

• database| redis| kafka|mysql|dive

• database | mysql |dive

• database｜How to determine（判断） master in mysql master-slave

• MySQL|并发控制

• MySQL|锁操作的本质

• MySQL｜MHA 高可用了解

• MySQL高并发场景了解02

• MySQL高并发场景了解01

• Mysql | innodb

• es vs mysql

• 测试记录:Mac单机MySQL数据库记录插入时间比较

• mysql  5.7.15编译安装

• MySQL 5.7 JSON类型，底部附云栖大会部分资料下载链接

• 数据库重构与领域驱动设计

• 数据库｜重新理解事务01

• 数据库｜体系结构

• 数据库｜基于内存的持久性

• 数据库｜京东智联云新一代分布式数据库TiDB架构揭秘

• 数据库治理的探索与实践

• 全链路灰度在数据库上我们是怎么做的？

• 政务云高性能数据库探索与实践

• 数据库纳管平台DBhouse的技术路线与实践

• 数据库：分区

• 分布式系统数据库分片认识

• 阳振坤：分布式技术引领关系数据库发展

• 数据库：索引

• 数据库：事务

• 数据库：方法学

• 数据库：分布式

• 数据库｜MySQL innodb 行记录存储学习

• 数据库｜mysql-8.0.27 源代码入口函数

• 数据库｜数据存储结构深入

• 数据库｜子查询，松散扫描，首次匹配

• 数据库｜标量子查询，联合主键索引，联合唯一索引，索引类型｜复习

• 分布式数据库 Join 查询设计与实现浅析
  

• 保驾护航 – Amazon RDS for MySQL 5.7 到 8.0 升级优势

• 浅谈Mysql读写分离的坑以及应对的方案

• 数据库MySQL8.0.27在MacOS下的编译问题记录

• 高性能MySQL实战（三）：性能优化

• C++ mysql8.0.27在mac上的openssl 必须是1.1版本

• 
  

• 国产数据库OceanBase 4.2特性解读：Show Trace全链路跟踪，助力快速问题定位与精准诊断

• 如何优化 MySQL 数据库中的查询性能

• 构建高效数据流转的 ETL 系统：数据库 + Serverless 函数计算的最佳实践
  

• 政务云高性能数据库探索与实践
  

• OceanBase 源码解读（十一）：Location Cache 模块浅析
  

• 数据库纳管平台DBhouse的技术路线与实践

• database | mysql |dive
  

• database｜索引

• Database Sharding: Concepts and Examples

• 从一条SQL了解MYSQL的架构设计

• 数据库治理的探索与实践

• 数据库：索引

• 数据库：分区

• 数据库｜MYSQL-INNODB索引构成详解

• 分布式系统数据库分片认识