# 安装依赖（在 Jupyter 中执行）
#!pip install llama-index-core llama-index-llms-openai llama-index-embeddings-openai
#!pip install pypdf PyMuPDF python-dotenv

import os
from dotenv import load_dotenv

# 加载环境变量（.env 文件中需要配置 OPENAI_API_KEY）
load_dotenv(override=True)

# 验证 API Key
api_key = os.getenv("OPENAI_API_KEY")
base_url = os.getenv("OPENAI_BASE_URL")
if api_key:
    print(f"✅ OPENAI_API_KEY 已配置: {api_key[:20]}...")
else:
    raise ValueError("❌ 请设置 OPENAI_API_KEY 环境变量")

from llama_index.core import Settings
from llama_index.llms.openai import OpenAI
from llama_index.embeddings.openai import OpenAIEmbedding

# 配置 LLM（大语言模型）
Settings.llm = OpenAI(
    model="gpt-4o",           # 使用 GPT-4o 模型
    temperature=0,             # 降低随机性，输出更稳定
    api_key=api_key,
    api_base=base_url          # 可选：使用代理 API
)

# 配置 Embedding 模型（用于向量化）
Settings.embed_model = OpenAIEmbedding(
    model="text-embedding-3-small",  # OpenAI 最新嵌入模型
    api_key=api_key,
    api_base=base_url
)

from pathlib import Path
from llama_index.core import SimpleDirectoryReader

# 指定文档目录
doc_dir = Path("./data")

if not doc_dir.exists():
    raise FileNotFoundError(f"❌ 文档目录不存在: {doc_dir}")

# 创建文档读取器
reader = SimpleDirectoryReader(
    input_dir=str(doc_dir),    # 目标文件夹
    recursive=True,             # 递归读取子目录
    required_exts=[".pdf"]      # 仅处理 PDF 文件
)

# 加载文档
documents = reader.load_data()

print(f"✅ 成功加载 {len(documents)} 个文档片段")

# 查看第一个文档的结构
if documents:
    doc = documents[0]
    print(f"\n📄 示例文档结构:")
    print(f"   - 文本长度: {len(doc.text)} 字符")
    print(f"   - 元数据: {doc.metadata}")

from llama_index.core import VectorStoreIndex

# 从文档构建向量索引
index = VectorStoreIndex.from_documents(
    documents,
    show_progress=True  # 显示进度条
)

print("✅ 向量索引构建完成")

# 查看索引元数据
print(f"\n🔍 索引内部结构:")
print(f"   - 节点数量: {len(index.docstore.docs)} 个")
print(f"   - 向量维度: {index._embed_model.embed_batch_size}")

# 查看第一个节点的结构
first_node_id = list(index.docstore.docs.keys())[0]
first_node = index.docstore.docs[first_node_id]
print(f"\n📦 示例节点 (Node) 结构:")
print(f"   - 文本长度: {len(first_node.text)} 字符")
print(f"   - Node ID: {first_node.node_id}")
print(f"   - 元数据: {first_node.metadata}")

# 将索引转换为查询引擎
query_engine = index.as_query_engine(
    similarity_top_k=3  # 每次检索最相关的 3 个文档块
)

# 执行查询
question = "这篇文档主要讨论了哪些核心议题？"
print(f"\n❓ 问题: {question}")

response = query_engine.query(question)
print(f"\n💡 回答:\n{response}")

# 查看检索到的源文档
print("\n📚 检索到的源文档:")
for i, node in enumerate(response.source_nodes):
    print(f"\n--- 文档 {i+1} (相似度: {node.score:.4f}) ---")
    print(f"内容预览: {node.text[:200]}...")

# 安装多模态依赖
#!pip install llama-index-multi-modal-llms-openai PyMuPDF pillow llama-index-embeddings-clip git+https://github.com/openai/CLIP.git

import os
import fitz  # PyMuPDF
from pathlib import Path

def extract_images_from_pdf_page(doc, page_index: int, output_dir: str) -> list:
    """
    从 PDF 的指定页面提取所有图片并保存到磁盘

    Args:
        doc: PyMuPDF Document 对象
        page_index: 页面索引（从 0 开始）
        output_dir: 图片保存目录

    Returns:
        list: 保存的图片路径列表
    """
    # 获取指定页面
    page = doc[page_index]

    # 获取页面中的所有图片列表
    image_list = page.get_images(full=True)
    saved_images = []

    for image_index, img in enumerate(image_list):
        # xref 是图片的引用 ID
        xref = img[0]
        
        # 提取图片二进制数据和扩展名
        base_image = doc.extract_image(xref)
        image_bytes = base_image["image"]
        image_ext = base_image["ext"]

        # 生成唯一的图片文件名
        image_filename = f"page_{page_index+1}_img_{image_index+1}.{image_ext}"
        image_path = os.path.join(output_dir, image_filename)

        # 将图片数据保存到本地
        with open(image_path, "wb") as img_file:
            img_file.write(image_bytes)

        saved_images.append(image_path)

    return saved_images

# 使用 PyMuPDF 提取 PDF 中的图片
pdf_path = "./data/测试文档.pdf"
output_dir = "./extracted_images"

# 检查 PDF 文件是否存在
if Path(pdf_path).exists():

    # 创建图片输出目录
    os.makedirs(output_dir, exist_ok=True)
    print(f"\n📷 正在从 PDF 提取图片...")

    # 打开 PDF 文档
    doc = fitz.open(pdf_path)
    all_image_paths = []
    
    # 遍历文档的每一页
    for i in range(len(doc)):
        
        # 提取当前页面的所有图片并返回保存路径
        paths = extract_images_from_pdf_page(doc, i, output_dir)
        all_image_paths.extend(paths)
    
    # 关闭文档释放资源
    doc.close()

    print(f"✅ 共提取 {len(all_image_paths)} 张图片")
    print(f"📂 图片保存路径: {output_dir}")
else:
    print(f"⚠️ PDF 文件不存在: {pdf_path}")
    all_image_paths = []

from llama_index.multi_modal_llms.openai import OpenAIMultiModal
from llama_index.core.indices import MultiModalVectorStoreIndex
from llama_index.core import SimpleDirectoryReader

# 1. 配置多模态 LLM (GPT-4o)
openai_mm_llm = OpenAIMultiModal(
    model="gpt-4o",
    api_key=api_key,
    api_base=base_url,
    max_new_tokens=500
)

# 2. 加载数据：整合提取出的图片与原始文本
if all_image_paths:
    # 从指定输出目录加载所有提取到的图片文档
    image_reader = SimpleDirectoryReader(input_dir=output_dir)
    image_docs = image_reader.load_data()
    print(f"✅ 加载 {len(image_docs)} 个图片文档")
else:
    # 如果没有图片路径，则初始化为空列表以便后续合并
    image_docs = []

# 从原始 PDF 文件中加载文本内容
text_reader = SimpleDirectoryReader(input_files=[pdf_path])
text_docs = text_reader.load_data()

# 将文本和图片文档合并为统一的列表，作为多模态索引的数据源
all_docs = text_docs + image_docs

# 3. 构建多模态索引
print(f"\n🔧 正在构建多模态索引...")
mm_index = MultiModalVectorStoreIndex.from_documents(
    all_docs
)
print("✅ 多模态索引构建完成")

from llama_index.core.schema import ImageNode, TextNode

# 统计节点类型
text_nodes = [n for n in mm_index.docstore.docs.values() if isinstance(n, TextNode)]
image_nodes = [n for n in mm_index.docstore.docs.values() if isinstance(n, ImageNode)]

print(f"\n📊 索引节点统计:")
print(f"   - 文本节点: {len(text_nodes)} 个")
print(f"   - 图片节点: {len(image_nodes)} 个")
print(f"   - 总节点数: {len(mm_index.docstore.docs)} 个")

from llama_index.core import QueryBundle

# 1. 构造简短 Query 用于检索（避开 77 token 限制）
retrieval_query = "LangChain architecture diagram Data Connection Agents"
retrieval_bundle = QueryBundle(query_str=retrieval_query)

# 2. 检索相关节点
retriever = mm_index.as_retriever(similarity_top_k=3)
retrieved_nodes = retriever.retrieve(retrieval_bundle)

# 3. 使用完整问题进行问答
full_question = """文档第一页文本中提到"LangChain 像搭乐高积木一样组合组件"，请结合该页的架构图解释：位于 "Data Connection" 和 "Agents" 之间的核心模块是什么，它在乐高组合中起到了什么链接作用？请使用中文回答"""

print(f"\n❓ 完整问题: {full_question}")

# 4. 创建查询引擎并生成答案
engine = mm_index.as_query_engine(
    image_llm=openai_mm_llm,
    similarity_top_k=3
)

# 将完整问题封装为 QueryBundle 对象
full_query_bundle = QueryBundle(query_str=full_question)

# 4. 创建引擎并合成回答
# 注意：我们需要先创建一个"空"的 engine，然后手动调用 synthesize
result = engine.synthesize(
    full_query_bundle, 
    nodes=retrieved_nodes
)

print(f"\n💡 回答:\n{result}")

# 展示检索到的图片引用
print("\n📚 检索到的源节点:")
for i, node in enumerate(retrieved_nodes):
    node_type = type(node.node).__name__
    print(f"  [{i+1}] 类型: {node_type}, 相似度: {node.score:.4f}")
    
    if isinstance(node.node, ImageNode):
        file_path = node.node.metadata.get('file_path', '未知')
        print(f"      📷 引用图片: {file_path}")
    else:
        print(f"      📄 文本预览: {node.node.text[:100]}...")

# 安装 LlamaParse 依赖
#!pip install llama-parse nest_asyncio

!pip list | grep llama-parse

import nest_asyncio
nest_asyncio.apply()  # 允许嵌套事件循环

from llama_parse import LlamaParse
from dotenv import load_dotenv
import os
load_dotenv(override=True)

# 获取 LlamaCloud API Key
llama_cloud_key = os.getenv("LLAMA_CLOUD_API_KEY")

if llama_cloud_key:
    # 配置解析器（高级参数）
    parser = LlamaParse(
        api_key=llama_cloud_key,
        result_type="markdown",    # Markdown 最适合 LLM 阅读
        verbose=True,              # 显示解析进度
        language="ch_sim",         # 优化中文 OCR 精度
        tier="cost_effective",         # 启用
        split_by_page=False        # 获得连续的 Markdown 文档
    )
    
    print("LlamaParse 配置成功（Markdown 模式）")
else:
    print("需要配置 LLAMA_CLOUD_API_KEY 环境变量")
    parser = None

from pathlib import Path
from llama_index.core import SimpleDirectoryReader

if parser:
    # 使用 LlamaParse 解析 PDF
    file_extractor = {".pdf": parser}
    
    print(f"\n📄 正在解析: {Path(pdf_path).name}")
    
    # 使用 SimpleDirectoryReader 加载文件并应用自定义解析器
    llama_documents = SimpleDirectoryReader(
        input_files=[pdf_path],       # PDF 文件路径
        file_extractor=file_extractor # 自定义解析器
    ).load_data()
    
    print(f"✅ 解析完成，共 {len(llama_documents)} 个文档块")
    
    # 查看 Markdown 输出
    if llama_documents:
        print(f"\n📝 Markdown 输出预览:")
        print("-" * 60)
        print(llama_documents[0].text[:2000])
        print("-" * 60)

# --- 新增调试代码：查看 LlamaParse 到底把图片解析成了什么 ---
print("\n🧐 LlamaParse 解析结果深度透视:")
for doc in llama_documents:
    # 打印文档前 500 个字符
    content_preview = doc.text[5000:]
    print(f"\n📄 文档片段预览:\n{content_preview}...")
    
    # 检查是否包含图片标记
    if "![" in doc.text:
        print("\n✅ 发现 Markdown 图片标记 (LlamaParse 将图片转为了链接引用)")
    else:
        print("\n❌ 未发现图片标记")
  

from llama_index.core import VectorStoreIndex

if parser and llama_documents:
    
    # 使用 LlamaParse 结果构建索引
    llama_index = VectorStoreIndex.from_documents(
        llama_documents,   # LlamaParse 解析结果
        show_progress=True # 显示进度条
    )
    llama_query_engine = llama_index.as_query_engine(similarity_top_k=3)
    
    # 提问图片内容
    # question = """很多开发者觉得LangChain代码冗余、编写复杂，甚至有开发者觉得LangChain太过于复杂,用户反馈的声音和评论有哪些？"""
    question = """根据文档内容，LangChain 的整体架构包含哪几个核心层？请结合架构图进行说明。"""
    print(f"\n❓ 问题: {question}")
    
    response = llama_query_engine.query(question)
    print(f"\n💡 回答:\n{response}")
    

# 展示检索到的图片引用（从 response 对象中提取）
print("\n📚 response 对象中的源节点:")
if hasattr(response, 'source_nodes') and response.source_nodes:
    for i, node in enumerate(response.source_nodes):
        node_type = type(node.node).__name__
        print(f"  [{i+1}] 类型: {node_type}, 相似度: {node.score:.4f}")
        
        if isinstance(node.node, ImageNode):
            file_path = node.node.metadata.get('file_path', '未知')
            print(f"      📷 引用图片: {file_path}")
        else:
            print(f"      📄 文本预览: {node.node.text[:100]}...")
else:
    print("  ℹ️ result 对象中没有 source_nodes 属性")
    print(f"  ℹ️ result 对象类型: {type(result)}")
    print(f"  ℹ️ result 可用属性: {dir(result)}")

import nest_asyncio
nest_asyncio.apply()  # 允许嵌套事件循环

from llama_parse import LlamaParse
import os

# 获取 LlamaCloud API Key
llama_cloud_key = os.getenv("LLAMA_CLOUD_API_KEY")

if llama_cloud_key:
    # 配置解析器（高级参数）
    parser = LlamaParse(
        api_key=llama_cloud_key,
        result_type="markdown",    # Markdown 最适合 LLM 阅读
        verbose=True,              # 显示解析进度
        language="ch_sim",         # 优化中文 OCR 精度
        tier="agentic_plus",         # 启用深度理解模式
        split_by_page=False        # 获得连续的 Markdown 文档
    )
    
    print("LlamaParse 配置成功（Markdown 模式）")
else:
    print("需要配置 LLAMA_CLOUD_API_KEY 环境变量")
    parser = None

from pathlib import Path
from llama_index.core import SimpleDirectoryReader

if parser:
    # 使用 LlamaParse 解析 PDF
    file_extractor = {".pdf": parser}
    
    print(f"\n📄 正在解析: {Path(pdf_path).name}")
    
    # 使用 SimpleDirectoryReader 加载文件并应用自定义解析器
    llama_documents = SimpleDirectoryReader(
        input_files=[pdf_path],       # PDF 文件路径
        file_extractor=file_extractor # 自定义解析器
    ).load_data()
    
    print(f"✅ 解析完成，共 {len(llama_documents)} 个文档块")
    
    # 查看 Markdown 输出
    if llama_documents:
        print(f"\n📝 Markdown 输出预览:")
        print("-" * 60)
        print(llama_documents[0].text[:2000])
        print("-" * 60)

# --- 新增调试代码：查看 LlamaParse 到底把图片解析成了什么 ---
print("\n🧐 LlamaParse 解析结果深度透视:")
for doc in llama_documents:
    # 打印文档前 500 个字符
    content_preview = doc.text[5000:]
    print(f"\n📄 文档片段预览:\n{content_preview}...")
    
    # 检查是否包含图片标记
    if "![" in doc.text:
        print("\n✅ 发现 Markdown 图片标记 (LlamaParse 将图片转为了链接引用)")
    else:
        print("\n❌ 未发现图片标记")
  

from llama_index.core import VectorStoreIndex

if parser and llama_documents:
    
    # 使用 LlamaParse 结果构建索引
    llama_index = VectorStoreIndex.from_documents(
        llama_documents,   # LlamaParse 解析结果
        show_progress=True # 显示进度条
    )
    llama_query_engine = llama_index.as_query_engine(similarity_top_k=3)
    
    # 提问图片内容
    question = """：根据文档内容，LangChain 的整体架构包含哪几个核心层？请结合架构图进行说明。"""
    print(f"\n❓ 问题: {question}")
    
    response = llama_query_engine.query(question)
    print(f"\n💡 回答:\n{response}")
    

# 展示检索到的图片引用（从 response 对象中提取）
print("\n📚 response 对象中的源节点:")
if hasattr(response, 'source_nodes') and response.source_nodes:
    for i, node in enumerate(response.source_nodes):
        node_type = type(node.node).__name__
        print(f"  [{i+1}] 类型: {node_type}, 相似度: {node.score:.4f}")
        
        if isinstance(node.node, ImageNode):
            file_path = node.node.metadata.get('file_path', '未知')
            print(f"      📷 引用图片: {file_path}")
        else:
            print(f"      📄 文本预览: {node.node.text[:100]}...")
else:
    print("  ℹ️ result 对象中没有 source_nodes 属性")
    print(f"  ℹ️ result 对象类型: {type(result)}")
    print(f"  ℹ️ result 可用属性: {dir(result)}")

# VLM 的实际输出示例（简化版）
{
  "page_1": {
    "page_size": [595, 842], # 页面尺寸 [宽, 高]
    "blocks": [
      {
        "id": 1,          
        "type": "title",            # 块类型：标题
        "bbox": [121, 46, 848, 105],    # 边界框坐标 [x1, y1, x2, y2]
        "content": "LangChain快速入门与Agent开发实战-Part 1", # 文本内容
        "level": 1         # 标题层级
      },
      {
        "id": 2,          
        "type": "text",       # 块类型：正文文本
        "bbox": [119, 225, 875, 318], # 边界框坐标
        "content": "LangChain可以称之为自2022年底大模型技术爆火以来的第一个...", # 文本内容
        "related_to": null # 关联的其他块 ID（如跨行/跨页关联）
      },
      { 
        "id": 3, 
        "type": "image_body", # 块类型：图片主体
        "bbox": [122, 476, 875, 743], # 边界框坐标
        "img_path": "images/7598546b...e0a184e.jpg", # 切图保存路径
        "content": null # 图片内的 OCR 文本（如有）
      },
      {
        "id": 4, 
        "type": "image_caption", # 块类型：图片说明/脚注
        "bbox": [86, 634, 295, 648], # 边界框坐标
        "content": "LangChain官网：https://www.langchain.com/", # 说明文字
        "linked_img_id": 3 # 关联的图片主体 ID
      },
      {
        "id": 5, 
        "type": "table",          # 块类型：表格
        "bbox": [159, 454, 875, 728], # 边界框坐标
        "img_path": "images/721c4e03...45cb49f.jpg", # 表格切图路径
        "table_body": "<table><tr><td>模块类别</td><td>示例功能</td></tr>...</table>" # 表格的 HTML 结构化重建结果
      }
    ]
  }
}

# OCR 对 text_zone 区域的处理
for block in layout["layout"]:
    if block["text_zone"]:
        # 1. 提取坐标框对应的像素区域
        region_image = extract_region(pdf_image, block["bbox"])
        
        # 2. 调用 PaddleOCR 识别
        ocr_result = paddleocr.ocr(region_image, language='ch')
        
        # 3. 合并识别结果为完整文本
        block["text"] = merge_ocr_lines(ocr_result)

# 图片提取与保存
for block in layout["layout"]:
    if block["image_zone"]:
        # 1. 提取坐标框对应的像素区域
        image_region = extract_region(pdf_image, block["bbox"])
        
        # 2. 保存为独立文件
        image_path = f"output/images/page_{page_num}_fig_{block['id']}.png"
        save_image(image_region, image_path)
        
        # 3. 在 Markdown 中插入引用
        block["md_reference"] = f"![Figure {block['id']}]({image_path})"

# 按阅读顺序生成 Markdown
markdown_output = []
for block_id in layout["reading_order"]:
    block = layout["layout"][block_id - 1]
    
    if block["type"] == "title":
        level = "#" * block["level"]
        markdown_output.append(f"{level} {block['text']}")
    
    elif block["type"] == "body":
        markdown_output.append(block["text"])
    
    elif block["type"] == "figure":
        markdown_output.append(block["md_reference"])
        # 如果有关联的说明文字，追加
        if block.get("linked_caption"):
            markdown_output.append(f"*{block['linked_caption']}*")

final_markdown = "\n\n".join(markdown_output)

%%markdown
# 系统架构设计

本节介绍了基于 LangChain 的智能问答系统架构。

![Figure 3](output/images/page_1_fig_3.png)
*图 3: LangChain 核心模块关系图*

从上图可以看出，Data Connection 模块位于 Model I/O 和 Agents 之间...

# MinerU 输出的 Documents 示例
documents = [
    # 文本节点
    Document(
        text="# 系统架构设计\n\n本节介绍了基于 LangChain 的智能问答系统架构...",
        metadata={"page": 1, "type": "text", "linked_images": ["page_1_fig_3.png"]}
    ),
    
    # 图片节点
    ImageDocument(
        image_path="output/images/page_1_fig_3.png",
        text="图 3: LangChain 核心模块关系图",  # 图片说明文字
        metadata={"page": 1, "type": "image", "linked_text_block": "block_2"}
    )
]

# 检索逻辑（伪代码）
def retrieve_with_linked_images(query, documents):
    # 1. 先检索文本节点
    text_nodes = text_retriever.retrieve(query, top_k=3)
    
    # 2. 自动扩展关联的图片节点
    all_nodes = []
    for node in text_nodes:
        all_nodes.append(node)
        # 如果该文本节点关联了图片，自动添加
        if "linked_images" in node.metadata:
            for img_path in node.metadata["linked_images"]:
                img_node = find_image_document(img_path)
                all_nodes.append(img_node)
    
    return all_nodes

{
  "pdf_info": [
    {
      "para_blocks": [
        {
          "type": "title",
          "bbox": [72, 39, 505, 89],
          "lines": [{"spans": [{"content": "LangChain快速入门...", "bbox": [...]}]}]
        }
      ]
    }
  ]
}

[
  [ // Page 0
    {
      "type": "title",
      "bbox": [0.122, 0.047, 0.85, 0.106],
      "content": "LangChain快速入门与Agent开发实战-Part 1"
    },
    {
      "type": "image",
      "bbox": [0.123, 0.477, 0.877, 0.744],
      "content": null  // 图片块本身没有文字内容
    }
  ]
]

[
  {
    "type": "text",
    "text": "一、LangChain.ai工具生态介绍",
    "text_level": 1,
    "page_idx": 0
  },
  {
    "type": "image",
    "img_path": "images/7598546b...e0a184e.jpg", // 对应 images 目录
    "image_caption": ["LangChain官网：https://www.langchain.com/"],
    "page_idx": 0
  }
]

#!pip install llama-index-core requests dashscope llama-index-vector-stores-milvus "pymilvus[milvus_lite]"

import os
from dotenv import load_dotenv

# 加载环境变量
load_dotenv(override=True)

# 检查 Key 是否存在
mineru_key = os.getenv("MINERU_API_KEY")
dashscope_key = os.getenv("DASHSCOPE_API_KEY")

if not mineru_key:
    print("❌ 错误：未找到 MINERU_API_KEY，请在 .env 文件中配置")
else:
    print(f"✅ 成功加载 MinerU Key: {mineru_key[:6]}******")

if dashscope_key:
    print(f"✅ 成功加载 DashScope Key: {dashscope_key[:6]}******")

# === Cell 2: 终极适配版 MinerUAPIReader (适配 full.md) ===
import time
import requests
import zipfile
import shutil
import os
import json
from pathlib import Path
from typing import List
from llama_index.core import Document
from llama_index.core.schema import ImageDocument

class MinerUAPIReader:
    def __init__(self, api_key: str, output_dir="./mineru_output"):
        self.api_key = api_key
        self.base_url = "https://mineru.net/api/v4"
        self.output_dir = Path(output_dir)

    def load_data(self, pdf_url: str) -> List[Document]:
        """
        核心方法：传入 PDF URL -> 轮询 -> 下载 ZIP -> 提取 full.md 和图片
        【原理】MinerU 采用 "VLM + OCR" 的分层解析策略：
        1. VLM (视觉大模型) 进行版面分析，识别标题、正文、图片、表格区域。
        2. OCR/提取 识别文字内容。
        3. 最终输出：将“肉”（文本）和“骨头”（图片）分离，文本存为 md，图片存为独立文件。
        """
        if not pdf_url.startswith("http"):
            raise ValueError("❌ 请传入有效的公网 URL (http/https)")

        # 1. 提交解析任务
        print(f"🚀 [MinerU] 提交解析任务 URL: {pdf_url[:50]}...")
        headers = {
            "Content-Type": "application/json",
            "Authorization": f"Bearer {self.api_key}"
        }
        
        data = {
            "url": pdf_url,
            "model_version": "vlm",  # 保持 VLM 模式 (利用视觉大模型进行版面分析)
            "is_ocr": True,          # 开启 OCR 以识别文本
            "lang": "auto"
        }
        
        try:
            resp = requests.post(f"{self.base_url}/extract/task", headers=headers, json=data)
            resp_json = resp.json()
            
            if resp.status_code != 200 or resp_json.get('code') != 0:
                print(f"❌ 提交失败响应: {resp.text}")
                raise Exception(f"API 请求失败: {resp_json.get('msg', '未知错误')}")
                
            task_id = resp_json['data'] # 获取 task_id 字符串 (v4 接口直接返回 ID)
            # 如果 data 是字典，尝试获取 task_id 字段 (容错)
            if isinstance(task_id, dict):
                task_id = task_id.get('task_id')
                
            print(f"⏳ [MinerU] 任务 ID: {task_id}，正在解析中...")
            
        except Exception as e:
            raise Exception(f"提交任务出错: {e}")

        # 2. 轮询结果
        result_url = None
        start_time = time.time()
        timeout = 600 # 10分钟超时，防止大文件解析慢
        
        while True:
            if time.time() - start_time > timeout:
                raise TimeoutError("解析超时")
            
            time.sleep(3)
            
            try:
                status_resp = requests.get(f"{self.base_url}/extract/task/{task_id}", headers=headers)
                if status_resp.status_code != 200:
                    continue
                
                status_json = status_resp.json()
                
                # 容错处理：确保 data 存在
                if 'data' not in status_json:
                    continue 

                status_data = status_json['data']
                state = status_data['state']
                
                if state == 'done':
                    result_url = status_data['full_zip_url']
                    print("") # 换行
                    break
                elif state in ['failed', 'error', 'cancelled']:
                    raise Exception(f"解析最终失败，状态: {state}")
                else:
                    print(f".", end="", flush=True) # 打印进度点
            except Exception as e:
                # 网络波动不中断，继续重试
                print(f"⚠️ 轮询波动: {e}")
                time.sleep(2)
                continue
        
        print(f"\n✅ [MinerU] 解析完成，开始处理结果包...")
        return self._process_zip(result_url, str(task_id))

    def _process_zip(self, url, task_id) -> List[Document]:
        # 清理并创建目录
        extract_path = self.output_dir / task_id
        if extract_path.exists():
            shutil.rmtree(extract_path)
        extract_path.mkdir(parents=True, exist_ok=True)
        
        # 下载 Zip
        zip_path = extract_path / "result.zip"
        try:
            print(f"📥 正在下载结果包...")
            with requests.get(url, stream=True) as r:
                r.raise_for_status()
                with open(zip_path, 'wb') as f:
                    shutil.copyfileobj(r.raw, f)
        except Exception as e:
            raise Exception(f"下载结果 zip 失败: {e}")
        
        # 解压
        try:
            with zipfile.ZipFile(zip_path, 'r') as z:
                z.extractall(extract_path)
        except Exception:
            raise Exception("文件解压失败")
            
        # 封装 Document
        documents = []
        try:
            # === 关键修正：根据您的截图寻找 full.md ===
            # 使用 rglob 递归查找，因为 full.md 可能在 task_id 同名子目录里
            md_files = list(extract_path.rglob("full.md"))
            
            if not md_files:
                # 容错：如果找不到 full.md，尝试找任何 .md 文件
                md_files = list(extract_path.rglob("*.md"))
                
            if not md_files:
                print(f"⚠️ 警告：解压目录中未找到 full.md。目录内容: {[p.name for p in extract_path.rglob('*')]}")
                return []
                
            target_md_file = md_files[0]
            print(f"📖 锁定核心文档: {target_md_file.name} (路径: {target_md_file.parent.name})")
            
        except Exception as e:
            print(f"⚠️ 文件结构错误: {e}")
            return []
            
        # 1. 读取 Markdown 文本
        # 原理：这是被"剔除"了图片的纯文本骨架，保留了 Markdown 格式的标题层级
        with open(target_md_file, 'r', encoding='utf-8') as f:
            documents.append(Document(
                text=f.read(), 
                metadata={"file_name": "mineru_doc.pdf", "task_id": task_id}
            ))
            
        # 2. 读取图片 (images 文件夹通常和 full.md 在同一级)
        # 原理：这是由 VLM 视觉模型基于版面分析精准"抠"出来的图片，通常包含了最重要的信息
        images_dir = target_md_file.parent / "images"
        if images_dir.exists():
            valid_images = [
                img for img in images_dir.iterdir() 
                if img.suffix.lower() in ['.jpg', '.png', '.jpeg'] and img.stat().st_size > 2048 # 过滤小图
            ]
            print(f"📸 [MinerU] 成功提取图表: {len(valid_images)} 张")
            for img in valid_images:
                documents.append(ImageDocument(
                    image_path=str(img), 
                    metadata={"file_name": "mineru_doc.pdf", "task_id": task_id}
                ))
        else:
            print("ℹ️ 未发现 images 文件夹，可能是纯文本文档。")
                
        return documents

print("✅ 终极适配版 MinerUAPIReader 定义完成！")

# === Cell 2 (Qwen2.5-VL 适配版): 定义 DashScopeEmbedding 类 ===
from typing import Any, List
from llama_index.core.embeddings import MultiModalEmbedding
from llama_index.core.schema import ImageType
import dashscope
from http import HTTPStatus
import asyncio
from pathlib import Path

class DashScopeMultiModalEmbedding(MultiModalEmbedding):
    """
    适配阿里百炼最新 Qwen2.5-VL-Embedding 模型
    """
    def __init__(self, api_key: str, model_name: str = "qwen2.5-vl-embedding"):
        super().__init__(model_name=model_name)
        dashscope.api_key = api_key

    # --- 通用调用逻辑 (私有方法) ---
    def _call_api(self, input_data: list) -> List[float]:
        """
        统一处理 API 调用与结果解析
        input_data 示例: [{'text': 'hello'}] 或 [{'image': 'file://...'}]
        """
        try:
            resp = dashscope.MultiModalEmbedding.call(
                model=self.model_name,
                input=input_data
            )
            
            if resp.status_code == HTTPStatus.OK:
                # 适配新版返回结构: output -> embeddings -> [0] -> embedding
                if 'embeddings' in resp.output and len(resp.output['embeddings']) > 0:
                    return resp.output['embeddings'][0]['embedding']
                else:
                    print(f"⚠️ API 返回结果为空: {resp}")
                    return [0.0] * 1024 # 假设维度，避免程序崩溃
            else:
                print(f"⚠️ API 调用失败: {resp.message}")
                return [0.0] * 1024
        except Exception as e:
            print(f"⚠️ 网络或处理异常: {e}")
            return [0.0] * 1024

    # --- 1. 图片向量化 ---
    def _get_image_embedding(self, img_file_path: ImageType) -> List[float]:
        # 必须转换为绝对路径并加 file:// 前缀
        abs_path = Path(img_file_path).absolute()
        input_data = [{'image': f"file://{abs_path}"}]
        return self._call_api(input_data)

    # --- 2. 文档文本向量化 ---
    def _get_text_embedding(self, text: str) -> List[float]:
        input_data = [{'text': text}]
        return self._call_api(input_data)

    # --- 3. 查询文本向量化 ---
    def _get_query_embedding(self, query: str) -> List[float]:
        input_data = [{'text': query}]
        return self._call_api(input_data)

    # --- 4. 异步方法 ---
    async def _aget_image_embedding(self, img_file_path: ImageType) -> List[float]:
        return self._get_image_embedding(img_file_path)

    async def _aget_text_embedding(self, text: str) -> List[float]:
        return self._get_text_embedding(text)
    
    async def _aget_query_embedding(self, query: str) -> List[float]:
        return self._get_query_embedding(query)

print(f"✅ Qwen2.5-VL 适配版 Embedding 类定义完成！")

# 准备测试 PDF（公网 URL）
test_url = "https://ml2022.oss-cn-hangzhou.aliyuncs.com/0.LangChain技术生态介绍.pdf"

# 实例化读取器
reader = MinerUAPIReader(api_key=mineru_key)

# 执行解析
print(f"🔄 开始解析 PDF: {test_url}\n")
documents = reader.load_data(test_url)

# 分析结果
text_docs = [d for d in documents if not isinstance(d, ImageDocument)]
image_docs = [d for d in documents if isinstance(d, ImageDocument)]

print(f"\n📊 解析结果统计:")
print(f"   - 文本文档: {len(text_docs)} 个")
print(f"   - 图片文档: {len(image_docs)} 个")
print(f"   - 总节点数: {len(documents)} 个")

# 查看文本文档的前 500 字符
if text_docs:
    print(f"\n📝 Markdown 输出预览:")
    print("-" * 60)
    print(text_docs[0].text[:500])
    print("-" * 60)

# 查看提取的图片列表
if image_docs:
    print(f"\n📷 提取的图片列表 (共 {len(image_docs)} 张):")
    for i, img_doc in enumerate(image_docs[:5]):
        # ImageDocument 的图片路径通常存储在 image_path 属性中
        if hasattr(img_doc, 'image_path'):
            image_path = img_doc.image_path
        elif hasattr(img_doc, 'image'):
            image_path = img_doc.image  # 可能是 base64 或路径
        else:
            # 如果都没有，显示 metadata 信息
            image_path = f"图片来自: {img_doc.metadata.get('file_name', '未知')} (task: {img_doc.metadata.get('task_id', 'N/A')[:8]}...)"
        
        print(f"   {i+1}. {image_path}")
    
    # 可选：查看第一张图片的完整属性
    print(f"\n   [调试] 第一张图片的属性:")
    print(f"   - dir(img_doc): {[attr for attr in dir(image_docs[0]) if not attr.startswith('_')]}")

# === Cell 4: 索引构建 (最终测试) ===
from llama_index.core.indices.multi_modal import MultiModalVectorStoreIndex
from llama_index.core import StorageContext, load_index_from_storage, Settings
import os

# 1. 实例化新版 Embedding
embed_model = DashScopeMultiModalEmbedding(api_key=dashscope_key)

# ⚠️ 关键修正：强制设置全局 Embedding 模型，避免 Query 时自动退回 OpenAI (1536维)
Settings.embed_model = embed_model
Settings.image_embed_model = embed_model  # 可选但推荐

# 2. 持久化索引
persist_dir = "./storage_qwen_vl"

if os.path.exists(persist_dir):
    print(f"📂 加载本地索引: {persist_dir} ...")
    storage_context = StorageContext.from_defaults(persist_dir=persist_dir)
    index = load_index_from_storage(storage_context)
    print("✅ 加载完成")
else:
    print("🧠 正在调用 Qwen2.5-VL 构建图文索引...")
    
    # 关键：同时指定 embed_model 和 image_embed_model
    index = MultiModalVectorStoreIndex.from_documents(
        documents,
        embed_model=embed_model,       # 文本 -> Qwen2.5
        image_embed_model=embed_model  # 图片 -> Qwen2.5
    )
    
    print(f"💾 保存索引至 {persist_dir} ...")
    index.storage_context.persist(persist_dir=persist_dir)
    print("✅ 构建并保存完成")

# --- 简单验证一下维度 ---
print("🎉 RAG 引擎就绪！")

# ==========================================
# 3. 核心：配置 Milvus 双路存储
# ==========================================
from llama_index.vector_stores.milvus import MilvusVectorStore
from llama_index.core import StorageContext

print("\n⚙️ 配置 Milvus 双路存储...")

MILVUS_URI = "http://localhost:19530"

# 3.1 创建文本向量存储 (Text Store)
text_store = MilvusVectorStore(
    uri=MILVUS_URI,
    collection_name="rag_prod_text",  # 独立的文本 Collection
    dim=1024,                         # 与 Qwen-VL 维度一致
    overwrite=True,                   # 测试模式：覆盖重建
    text_key="text"                # 使用默认字段名
)

# 3.2 创建图片向量存储 (Image Store)
image_store = MilvusVectorStore(
    uri=MILVUS_URI,
    collection_name="rag_prod_image", # 独立的图片 Collection
    dim=1024,                         # 与 Qwen-VL 维度一致
    overwrite=True,                   # 测试模式：覆盖重建
    text_key="text"                   # 图片元数据偶尔也会用到文本字段
)

# 3.3 组合 Storage Context
# 关键：正确注册 image_store 到 vector_stores 字典中
IMAGE_VECTOR_STORE_KEY = "image"
storage_context = StorageContext.from_defaults(vector_store=text_store)
storage_context.vector_stores[IMAGE_VECTOR_STORE_KEY] = image_store