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

显示全部楼层

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

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

一、查询引擎概览

1.1 查询类型

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

frompymilvusimportCollection

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（抽象语法树）：

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

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

// AST 节点
typeExprNodestruct{
  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 查询计划生成

// 查询计划器
typeQueryPlannerstruct{
  schema *Schema
  stats *Statistics
}

// 生成查询计划
func(qp *QueryPlanner)Plan(req *SearchRequest)(*QueryPlan, error){
  plan := &QueryPlan{}
 
 // 1. 解析表达式
 ifreq.Expr !=""{
    exprNode, err := qp.parseExpr(req.Expr)
   iferr !=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)
 
 returnplan,nil
}

// 查询计划
typeQueryPlanstruct{
 // 过滤条件
  FilterNode *ExprNode
 
 // 向量检索
  VectorIndex *IndexInfo
  VectorField string
  MetricType string
  SearchParamsmap[string]interface{}
 
 // 标量索引
  ScalarIndexes []*IndexInfo
 
 // 执行顺序
  ExecutionOrder []PlanNode
 
 // 成本估算
  Costfloat64
}

2.3 查询优化

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

// 将过滤条件尽早应用，减少数据量
func(qp *QueryPlanner)pushDownPredicate(plan *QueryPlan){
 // 原始计划：
 // 1. 向量检索 → 10000 个结果
 // 2. 标量过滤 → 100 个结果
 
 // 优化后：
 // 1. 标量过滤 → 1000 个候选
 // 2. 向量检索 → 100 个结果
 
 ifplan.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 :=rangecandidates[1:] {
    cost := qp.estimateIndexCost(idx, expr)
   ifcost < minCost {
      minCost = cost
      bestIndex = idx
    }
  }
 
 returnbestIndex
}

优化 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
 fori :=0; i < numWorkers; i++ {
   gofunc(){
     forseg :=rangejobs {
        result := qn.searchSegment(seg, plan)
        results <- result
      }
    }()
  }
 
 // 分发任务
 for_, seg :=rangesegments {
    jobs <- seg
  }
 close(jobs)
 
 // 收集结果
  allResults :=make([]*SearchResult,0,len(segments))
 fori :=0; i <len(segments); i++ {
    allResults =append(allResults, <-results)
  }
 
 returnallResults
}

三、向量检索执行

3.1 Segment 内检索

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

// HNSW 索引检索
func(idx *HNSWIndex)Search(query []float32, kint, bitset *Bitset)*SearchResult{
 // 1. 从入口点开始
  ep := idx.entryPoint
 
 // 2. 逐层贪心搜索
 forlevel := 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
 returncandidates.TopK(k)
}

// 搜索层
func(idx *HNSWIndex)searchLayer(
  query []float32,
  entryPoint *Node,
  numClosestint,
  layerint,
  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
 
 // 贪心搜索
 forcandidates.Len() >0{
    current := candidates.Pop()
   
   // 如果当前点比结果中最远的点还远，停止
   ifcurrent.Distance > results.Top().Distance {
     break
    }
   
   // 扩展邻居
   for_, neighbor :=rangecurrent.Node.Neighbors[layer] {
     ifvisited[neighbor.ID] {
       continue
      }
      visited[neighbor.ID] =true
     
     // 应用 Bitset 过滤
     ifbitset !=nil&& !bitset.Test(neighbor.ID) {
       continue
      }
     
      dist := idx.distance(query, neighbor.Vector)
     
     ifdist < results.Top().Distance || results.Len() < numClosest {
        candidates.Push(&Candidate{Node: neighbor, Distance: dist})
        results.Push(&Candidate{Node: neighbor, Distance: dist})
       
       ifresults.Len() > numClosest {
          results.Pop()
        }
      }
    }
  }
 
 returnresults.ToSlice()
}

3.2 标量过滤

// 标量过滤器
typeScalarFilterstruct{
  expr  *ExprNode
  schema *Schema
}

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

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

func(sf *ScalarFilter)evaluateNode(node *ExprNode, segment *Segment, rowIDint)bool{
 switchnode.Type {
 caseNodeType_AND:
   returnsf.evaluateNode(node.Left, segment, rowID) &&
       sf.evaluateNode(node.Right, segment, rowID)
 
 caseNodeType_OR:
   returnsf.evaluateNode(node.Left, segment, rowID) ||
       sf.evaluateNode(node.Right, segment, rowID)
 
 caseNodeType_EQ:
    fieldValue := segment.GetFieldValue(node.FieldID, rowID)
   returnfieldValue == node.Value
 
 caseNodeType_GT:
    fieldValue := segment.GetFieldValue(node.FieldID, rowID)
   returnfieldValue.(float64) > node.Value.(float64)
 
 caseNodeType_IN:
    fieldValue := segment.GetFieldValue(node.FieldID, rowID)
    values := node.Value.([]interface{})
   for_, v :=rangevalues {
     iffieldValue == v {
       returntrue
      }
    }
   returnfalse
 
 default:
   returnfalse
  }
}

3.3 距离计算优化

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

// L2 距离（欧氏距离）
funcL2Distance(a, b []float32)float32{
 ifcpu.X86.HasAVX2 {
   returnl2DistanceAVX2(a, b)
  }
 returnl2DistanceScalar(a, b)
}

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

// 标量版本
funcl2DistanceScalar(a, b []float32)float32{
 varsumfloat32
 fori :=rangea {
    diff := a[i] - b[i]
    sum += diff * diff
  }
 returnsum
}

// 余弦相似度
funcCosineSimilarity(a, b []float32)float32{
 vardotProduct, normA, normBfloat32
 
 fori :=rangea {
    dotProduct += a[i] * b[i]
    normA += a[i] * a[i]
    normB += b[i] * b[i]
  }
 
 returndotProduct / (sqrt(normA) * sqrt(normB))
}

// 内积
funcInnerProduct(a, b []float32)float32{
 varsumfloat32
 fori :=rangea {
    sum += a[i] * b[i]
  }
 returnsum
}

四、结果聚合与排序

4.1 多 Segment 结果合并

// Proxy 的结果聚合
func(p *Proxy)mergeResults(results []*SearchResult, topKint)*SearchResult{
 // 1. 使用最小堆合并多个有序列表
  heap := NewMinHeap()
 
 // 2. 初始化：每个结果的第一个元素入堆
 fori, result :=rangeresults {
   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),
  }
 
 forheap.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
   ifnextIdx <len(result.IDs) {
      heap.Push(&HeapNode{
        Distance: result.Distances[nextIdx],
        ID:    result.IDs[nextIdx],
        ResultIdx: node.ResultIdx,
        ItemIdx:  nextIdx,
      })
    }
  }
 
 returnmerged
}

4.2 分布式结果聚合

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

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

4.3 重排序（Reranking）

frompymilvusimportCollection, 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 重排序
funcRRFRerank(results [][]*SearchResult, kint)[]*SearchResult{
 // RRF 公式：score(d) = Σ 1 / (k + rank_i(d))
  scores :=make(map[int64]float64)
 
 for_, resultList :=rangeresults {
   forrank, result :=rangeresultList {
      scores[result.ID] +=1.0/float64(k + rank +1)
    }
  }
 
 // 按分数排序
  ranked :=make([]*SearchResult,0,len(scores))
 forid, score :=rangescores {
    ranked =append(ranked, &SearchResult{
      ID:  id,
      Score: score,
    })
  }
 
  sort.Slice(ranked,func(i, jint)bool{
   returnranked[i].Score > ranked[j].Score
  })
 
 returnranked
}

五、查询性能优化

5.1 缓存策略

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

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

5.2 预取（Prefetch）

// 预取下一批 Segment
func(qn *QueryNode)prefetchSegments(currentSegmentIDint64){
 // 预测下一个可能访问的 Segment
  nextSegments := qn.predictNextSegments(currentSegmentID)
 
 // 异步加载
 for_, segID :=rangenextSegments {
   gofunc(idint64){
      qn.loadSegment(id)
    }(segID)
  }
}

5.3 批量查询

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

# 批量查询（快 10 倍）
batch_size =100
foriinrange(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 复杂查询示例

frompymilvusimportCollection

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"]
)

# 处理结果
forhitinresults[0]:
  print(f"roduct:{hit.entity.get('name')}")
  print(f"rice: ${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
)

七、总结

核心要点

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

最佳实践

✅ 使用表达式过滤减少搜索空间 ✅ 批量查询提升吞吐量 ✅ 合理设置 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索引构成详解
分布式系统数据库分片认识