# 中央配置字典，用於管理所有系統參數config = {    "data_dir": "./data",                           # 存儲原始和清理後數據的目錄    "vector_store_dir": "./vector_store",           # 持久化向量存儲的目錄    "llm_provider": "openai",                       # 我們使用的 LLM 提供商    "reasoning_llm": "gpt-4o",                      # 用於規劃和綜合的強大模型    "fast_llm": "gpt-4o-mini",                      # 用於簡單任務（如基線 RAG）的更快速、更便宜的模型    "embedding_model": "text-embedding-3-small",    # 用於創建文檔嵌入的模型    "reranker_model": "cross-encoder/ms-marco-MiniLM-L-6-v2", # 用於精確重排序的模型    "max_reasoning_iterations": 7,                  # 防止智能體陷入無限循環的安全措施    "top_k_retrieval": 10,                          # 初始廣泛召回的文檔數量    "top_n_rerank": 3,                              # 精確重排序後保留的文檔數量}

import os                  # 用於與操作系統交互（例如，管理環境變量）import re                  # 用於正則表達式操作，有助於文本清理import json                # 用於處理 JSON 數據from getpass import getpass # 用於安全地提示用户輸入（如 API 密鑰），而不會在屏幕上回顯from pprint import pprint   # 用於美觀地打印 Python 對象，使其更具可讀性import uuid                # 用於生成唯一標識符from typing importList, Dict, TypedDict, Literal, Optional# 用於類型提示，以創建清晰、可讀和可維護的代碼# 輔助函數，用於在環境變量不存在時安全地設置它們def_set_env(var: str):    # 檢查環境變量是否尚未設置    ifnot os.environ.get(var):        # 如果未設置，則提示用户安全地輸入        os.environ[var] = getpass(f"Enter your {var}: ")# 設置我們將使用的服務的 API 密鑰_set_env("OPENAI_API_KEY")      # 用於訪問 OpenAI 模型（GPT-4o, embeddings）_set_env("LANGSMITH_API_KEY")   # 用於使用 LangSmith 進行追蹤和調試_set_env("TAVILY_API_KEY")      # 用於網絡搜索工具# 啓用 LangSmith 追蹤，以獲取我們智能體執行的詳細日誌和可視化os.environ["LANGSMITH_TRACING"] = "true"# 在 LangSmith 中定義一個項目名稱，以組織我們的運行記錄os.environ["LANGSMITH_PROJECT"] = "Advanced-Deep-Thinking-RAG"

import requests # 用於發起 HTTP 請求以下載文檔from bs4 import BeautifulSoup # 一個用於解析 HTML 和 XML 文檔的強大庫from langchain.docstore.document import Document # LangChain 中用於表示一段文本的標準數據結構defdownload_and_parse_10k(url, doc_path_raw, doc_path_clean):    # 檢查清理後的文件是否已存在，以避免重複下載    if os.path.exists(doc_path_clean):        print(f"Cleaned 10-K file already exists at: {doc_path_clean}")        return    print(f"Downloading 10-K filing from {url}...")    # 設置一個 User-Agent 請求頭來模擬瀏覽器，因為一些服務器會阻止腳本訪問    headers = {'User-Agent': 'Mozilla/5.0'}    # 向 URL 發起 GET 請求    response = requests.get(url, headers=headers)    # 如果下載失敗（例如，404 Not Found），則拋出錯誤    response.raise_for_status()    # 將原始 HTML 內容保存到文件中以便檢查    withopen(doc_path_raw, 'w', encoding='utf-8') as f:        f.write(response.text)    print(f"Raw document saved to {doc_path_raw}")    # 使用 BeautifulSoup 解析和清理 HTML 內容    soup = BeautifulSoup(response.content, 'html.parser')    # 從常見的 HTML 標籤中提取文本，並嘗試保留段落結構    text = ''    for p in soup.find_all(['p', 'div', 'span']):        # 獲取每個標籤的文本，去除多餘的空白，並添加換行符        text += p.get_text(strip=True) + '\n\n'    # 使用正則表達式清理多餘的換行符和空格，以獲得更乾淨的最終文本    clean_text = re.sub(r'\n{3,}', '\n\n', text).strip() # 將 3 個及以上的換行符合併為 2 個    clean_text = re.sub(r'\s{2,}', ' ', clean_text).strip() # 將 2 個及以上的空格合併為 1 個    # 將最終清理後的文本保存到 .txt 文件中    withopen(doc_path_clean, 'w', encoding='utf-8') as f:        f.write(clean_text)    print(f"Cleaned text content extracted and saved to {doc_path_clean}")

print("Downloading and parsing NVIDIA's 2023 10-K filing...")# 執行下載和解析函數download_and_parse_10k(url_10k, doc_path_raw, doc_path_clean)# 打開清理後的文件並打印一個樣本以驗證結果withopen(doc_path_clean, 'r', encoding='utf-8') as f:    print("\n--- Sample content from cleaned 10-K ---")    print(f.read(1000) + "...")#### OUTPUT ####Downloading and parsing NVIDIA 202310-K filing...Successfully downloaded 10-K filing from https://www.sec.gov/Archives/edgar/data/1045810/000104581023000017/nvda-20230129.htmRaw document saved to ./data/nvda_10k_2023_raw.htmlCleaned text content extracted and saved to ./data/nvda_10k_2023_clean.txt# --- Sample content from cleaned 10-K ---Item 1. Business.  OVERVIEW  NVIDIA is the pioneer of accelerated computing. We are a full-stack computing company with a platform strategy that brings together hardware, systems, software, algorithms, libraries, and services to create unique value for the markets we serve. Our work in accelerated computing and AI is reshaping the worlds largest industries and profoundly impacting society.  Founded in1993, we started as a PC graphics chip company, inventing the graphics processing unit, or GPU. The GPU was essential for the growth of the PC gaming market and has since been repurposed to revolutionize computer graphics, high performance computing, or HPC, and AI.  The programmability of our GPUs made them ...

我們的複雜查詢："根據 NVIDIA 的 2023 年 10-K 文件，找出其與競爭相關的關鍵風險。然後，查找關於 AMD 的 AI 芯片戰略的最新消息（文件發佈後，即 2024 年的新聞），並解釋這一新戰略如何直接應對或加劇了 NVIDIA 所陳述的風險之一。"

from langchain_community.document_loaders import TextLoader # 一個用於 .txt 文件的簡單加載器from langchain.text_splitter import RecursiveCharacterTextSplitter # 一個標準的文本分割器print("Loading and chunking the document...")# 使用我們清理後的 10-K 文件的路徑初始化加載器loader = TextLoader(doc_path_clean, encoding='utf-8')# 將文檔加載到內存中documents = loader.load()# 使用定義的塊大小和重疊來初始化文本分割器# chunk_size=1000: 每個塊大約 1000 個字符長。# chunk_overlap=150: 每個塊將與前一個塊共享 150 個字符以保持一定的上下文。text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=150)# 將加載的文檔分割成更小、更易於管理的塊doc_chunks = text_splitter.split_documents(documents)print(f"Document loaded and split into {len(doc_chunks)} chunks.")#### OUTPUT ####Loading and chunking the document...Document loaded and split into 378 chunks.

from langchain_community.vectorstores import Chroma # 我們將使用的向量存儲from langchain_openai import OpenAIEmbeddings # 用於創建嵌入的函數print("Creating baseline vector store...")# 使用我們配置中指定的模型初始化嵌入函數embedding_function = OpenAIEmbeddings(model=config['embedding_model'])# 從我們的文檔塊創建 Chroma 向量存儲# 這個過程會為每個塊創建一個嵌入，並將其索引化。baseline_vector_store = Chroma.from_documents(    documents=doc_chunks,    embedding=embedding_function)# 從向量存儲創建一個檢索器# 檢索器是實際執行搜索的組件。# search_kwargs={"k": 3}: 這告訴檢索器對於任何給定的查詢，返回最相關的 3 個塊。baseline_retriever = baseline_vector_store.as_retriever(search_kwargs={"k": 3})print(f"Vector store created with {baseline_vector_store._collection.count()} embeddings.")#### OUTPUT ####Creating baseline vector store...Vector store created with378 embeddings.

from langchain_core.prompts import ChatPromptTemplate # 用於創建提示模板from langchain_openai import ChatOpenAI # OpenAI 聊天模型接口from langchain_core.runnable import RunnablePassthrough # 一個用於在鏈中傳遞輸入的工具from langchain_core.output_parsers import StrOutputParser # 用於將 LLM 的輸出解析為簡單字符串# 這個模板指示 LLM 如何行事。# {context}: 這裏我們將注入從檢索到的文檔中獲得的內容。# {question}: 這裏將放入用户的原始問題。template = """You are an AI financial analyst. Answer the question based only on the following context:{context}Question: {question}"""prompt = ChatPromptTemplate.from_template(template)# 我們使用配置中定義的 'fast_llm' 來完成這個簡單的任務llm = ChatOpenAI(model=config["fast_llm"], temperature=0)# 一個輔助函數，用於將檢索到的文檔列表格式化為單個字符串defformat_docs(docs):    return"\n\n---\n\n".join(doc.page_content for doc in docs)# 使用 LCEL 的管道(|)語法定義的完整 RAG 鏈baseline_rag_chain = (    # 第一步是一個字典，定義了我們提示的輸入    {"context": baseline_retriever | format_docs, "question": RunnablePassthrough()}    # context 是通過將問題傳遞給檢索器並格式化結果來生成的    # 原始問題則原封不動地傳遞下去    | prompt # 然後這個字典被傳遞給提示模板    | llm # 格式化後的提示被傳遞給語言模型    | StrOutputParser() # LLM 的輸出消息被解析為字符串)

from rich.console import Console # 用於以 markdown 格式美觀地打印輸出from rich.markdown import Markdown# 初始化 rich 控制枱以獲得更好的輸出格式console = Console()# 我們的複雜、多跳、多源查詢complex_query_adv = "Based on NVIDIA's 2023 10-K filing, identify their key risks related to competition. Then, find recent news (post-filing, from 2024) about AMD's AI chip strategy and explain how this new strategy directly addresses or exacerbates one of NVIDIA's stated risks."print("Executing complex query on the baseline RAG chain...")# 使用我們具有挑戰性的查詢調用該鏈baseline_result = baseline_rag_chain.invoke(complex_query_adv)console.print("\n--- BASELINE RAG FAILED OUTPUT ---")# 使用 markdown 格式打印結果以提高可讀性console.print(Markdown(baseline_result))

#### OUTPUT ####Executing complex query on the baseline RAG chain...--- BASELINE RAG FAILED OUTPUT ---Based on the provided context, NVIDIA operates in an intensely competitive semiconductorindustry and faces competition from companies like AMD. The context mentionsthat the industry is characterized by rapid technological change. However, the provided documents do not contain any specific information about AMD's recent AI chip strategy from 2024 or how it might impact NVIDIA's stated risks.

from langchain_core.documents import Documentfrom langchain_core.pydantic_v1 import BaseModel, Field# 用於表示智能體推理計劃中單一步驟的 Pydantic 模型class Step(BaseModel):    # 此研究步驟的一個具體的、可回答的子問題    sub_question: str = Field(description="A specific, answerable question for this step.")    # 智能體對為何此步驟是必要的的論證    justification: str = Field(description="A brief explanation of why this step is necessary to answer the main query.")    # 此步驟要使用的具體工具：內部文檔搜索或外部網絡搜索    tool: Literal["search_10k", "search_web"] = Field(description="The tool to use for this step.")    # 一系列關鍵關鍵詞，以提高搜索的準確性    keywords: List[str] = Field(description="A list of critical keywords for searching relevant document sections.")    # (可選) 一個可能的文檔章節，用於執行更具針對性的、過濾後的搜索    document_section: Optional[str] = Field(description="A likely document section title (e.g., 'Item 1A. Risk Factors') to search within. Only for 'search_10k' tool.")

# 用於表示整個計劃的 Pydantic 模型，它是一個包含多個獨立步驟的列表class Plan(BaseModel):    # 一個 Step 對象的列表，概述了完整的系列研究計劃    steps: List[Step] = Field(description="A detailed, multi-step plan to answer the user's query.")

# 一個 TypedDict，用於在我們的研究歷史中存儲已完成步驟的結果class PastStep(TypedDict):    step_index: int              # 已完成步驟的索引（例如，1, 2, 3）    sub_question: str            # 在此步驟中解決的子問題    retrieved_docs: List[Document] # 為此步驟檢索和重排序的精確文檔    summary: str                 # 智能體對此步驟發現的一句話總結

# 將在我們 LangGraph 智能體所有節點之間傳遞的主狀態字典class RAGState(TypedDict):    original_question: str     # 用户發起的、啓動整個流程的初始複雜查詢    plan: Plan                 # 由規劃器智能體生成的多步驟計劃    past_steps: List[PastStep] # 已完成研究步驟及其發現的累積歷史    current_step_index: int    # 正在執行的計劃中當前步驟的索引    retrieved_docs: List[Document] # 當前步驟中檢索到的文檔（廣泛召回的結果）    reranked_docs: List[Document]  # 當前步驟中經過精確重排序後的文檔    synthesized_context: str   # 從重排序後的文檔中生成的簡潔、蒸餾的上下文    final_answer: str          # 對用户原始問題的最終、綜合性答案

from langchain_core.prompts import ChatPromptTemplatefrom langchain_openai import ChatOpenAIfrom rich.pretty import pprint as rprint# 指示 LLM 如何作為規劃器行事的系統提示planner_prompt = ChatPromptTemplate.from_messages([    ("system", """You are an expert research planner. Your task is to create a clear, multi-step plan to answer a complex user query by retrieving information from multiple sources.You have two tools available:1. `search_10k`: Use this to search for information within NVIDIA's 2023 10-K financial filing. This is best for historical facts, financial data, and stated company policies or risks from that specific time period.2. `search_web`: Use this to search the public internet for recent news, competitor information, or any topic that is not specific to NVIDIA's 2023 10-K.Decompose the user's query into a series of simple, sequential sub-questions. For each step, decide which tool is more appropriate.For `search_10k` steps, also identify the most likely section of the 10-K (e.g., 'Item 1A. Risk Factors', 'Item 7. Management's Discussion and Analysis...').It is critical to use the exact section titles found in a 10-K filing where possible."""),    ("human", "User Query: {question}") # 用户的原始、複雜查詢])

# 初始化我們強大的推理模型，如配置中所定義reasoning_llm = ChatOpenAI(model=config["reasoning_llm"], temperature=0)# 通過將提示管道連接到 LLM 並指示其使用我們的結構化 'Plan' 輸出，來創建規劃器智能體planner_agent = planner_prompt | reasoning_llm.with_structured_output(Plan)print("Tool-Aware Planner Agent created successfully.")# 讓我們用我們的複雜查詢來測試規劃器智能體，看看它的輸出print("\n--- Testing Planner Agent ---")test_plan = planner_agent.invoke({"question": complex_query_adv})# 使用 rich 的 pretty print 功能來清晰、可讀地顯示 Pydantic 對象rprint(test_plan)

#### OUTPUT ####Tool-Aware Planner Agent created successfully.--- Testing Planner Agent ---Plan(│   steps=[│   │   Step(│   │   │   sub_question="What are the key risks related to competition as stated in NVIDIA's 2023 10-K filing?",│   │   │   justification="This step is necessary to extract the foundational information about competitive risks directly from the source document as requested by the user.",│   │   │   tool='search_10k',│   │   │   keywords=['competition', 'risk factors', 'semiconductor industry', 'competitors'],│   │   │   document_section='Item 1A. Risk Factors'│   │   ),│   │   Step(│   │   │   sub_question="What are the recent news and developments in AMD's AI chip strategy in 2024?",│   │   │   justification="This step requires finding up-to-date, external information that is not available in the 2023 10-K filing. A web search is necessary to get the latest details on AMD's strategy.",│   │   │   tool='search_web',│   │   │   keywords=['AMD', 'AI chip strategy', '2024', 'MI300X', 'Instinct accelerator'],│   │   │   document_section=None│   │   )│   ])

from langchain_core.output_parsers import StrOutputParser # 用於將 LLM 的輸出解析為簡單字符串# 我們查詢重寫器的提示，指示它扮演搜索專家的角色query_rewriter_prompt = ChatPromptTemplate.from_messages([    ("system", """You are a search query optimization expert. Your task is to rewrite a given sub-question into a highly effective search query for a vector database or web search engine, using keywords and context from the research plan.The rewritten query should be specific, use terminology likely to be found in the target source (a financial 10-K or news articles), and be structured to retrieve the most relevant text snippets."""),    ("human", "Current sub-question: {sub_question}\n\nRelevant keywords from plan: {keywords}\n\nContext from past steps:\n{past_context}")])

# 通過將提示管道連接到我們的推理 LLM 和一個字符串輸出解析器來創建智能體query_rewriter_agent = query_rewriter_prompt | reasoning_llm | StrOutputParser()print("Query Rewriter Agent created successfully.")# 讓我們來測試重寫器智能體。我們將假裝已經完成了我們計劃的前兩個步驟。print("\n--- Testing Query Rewriter Agent ---")# 假設我們正處於一個需要前兩步上下文的最終綜合步驟。test_sub_q = "How does AMD's 2024 AI chip strategy potentially exacerbate the competitive risks identified in NVIDIA's 10-K?"test_keywords = ['impact', 'threaten', 'competitive pressure', 'market share', 'technological change']# 我們創建一些模擬的“過去上下文”來模擬智能體在真實運行中此時會知道什麼。test_past_context = "Step 1 Summary: NVIDIA's 10-K lists intense competition and rapid technological change as key risks. Step 2 Summary: AMD launched its MI300X AI accelerator in 2024 to directly compete with NVIDIA's H100."# 使用我們的測試數據調用智能體rewritten_q = query_rewriter_agent.invoke({    "sub_question": test_sub_q,    "keywords": test_keywords,    "past_context": test_past_context})print(f"Original sub-question: {test_sub_q}")print(f"Rewritten Search Query: {rewritten_q}")

#### OUTPUT ####Query Rewriter Agent created successfully.--- Testing Query Rewriter Agent ---Original sub-question: How does AMD 2024 AI chip strategy potentially exacerbate the competitive risks identified in NVIDIA 10-K?Rewritten Search Query: analysis of how AMD 2024 AI chip strategy, including products like the MI300X, exacerbates NVIDIA's stated competitive risks such as rapid technological change and market share erosion in the data center and AI semiconductor industry

# 這個正則表達式旨在查找 10-K 文本中像 'ITEM 1A.' 或 'ITEM 7.' 這樣的章節標題。# 它尋找單詞 'ITEM'，後跟一個空格、一個數字、一個可選的字母、一個句點，然後捕獲標題文本。# `re.IGNORECASE | re.DOTALL` 標誌使搜索不區分大小寫，並允許 '.' 匹配換行符。section_pattern = r"(ITEM\\s+\\d[A-Z]?\\.\\s*.*?)(?=\\nITEM\\s+\\d[A-Z]?\\.|$)"

# 我們將使用之前從 Document 對象中加載的原始文本raw_text = documents[0].page_content# 使用 re.findall 應用我們的模式，並將所有章節標題提取到一個列表中section_titles = re.findall(section_pattern, raw_text, re.IGNORECASE | re.DOTALL)# 一個快速的清理步驟，去除標題中任何多餘的空白或換行符section_titles = [title.strip().replace('\\n', ' ') for title in section_titles]# 現在，使用 re.split 在每個章節標題出現的地方將文檔分割開sections_content = re.split(section_pattern, raw_text, flags=re.IGNORECASE | re.DOTALL)# 分割結果是一個混合了標題和內容的列表，所以我們過濾它以只獲取內容部分sections_content = [content.strip() for content in sections_content if content.strip() andnot content.strip().lower().startswith('item ')]print(f"Identified {len(section_titles)} document sections.")# 這是一個至關重要的健全性檢查：如果標題的數量與內容塊的數量不匹配，説明出了問題。assertlen(section_titles) == len(sections_content), "Mismatch between titles and content sections"

import uuid # 我們將用它為每個塊賦予一個唯一的 ID，這是一個好習慣# 這個列表將存放我們新的、富含元數據的文檔塊doc_chunks_with_metadata = []# 使用 enumerate 遍歷每個章節的內容及其標題for i, content inenumerate(sections_content):    # 獲取當前內容塊對應的標題    section_title = section_titles[i]    # 使用和之前一樣的文本分割器，但這次，我們只在當前章節的內容上運行它    section_chunks = text_splitter.split_text(content)        # 現在，遍歷從這一個章節創建的更小的塊    for chunk in section_chunks:        # 為這個特定的塊生成一個唯一的 ID        chunk_id = str(uuid.uuid4())        # 為這個塊創建一個新的 LangChain Document 對象        doc_chunks_with_metadata.append(            Document(                page_content=chunk,                # 這是最重要的部分：我們附加元數據                metadata={                    "section": section_title,      # 這個塊所屬的章節                    "source_doc": doc_path_clean,  # 文檔來源                    "id": chunk_id                 # 這個塊的唯一 ID                }            )        )print(f"Created {len(doc_chunks_with_metadata)} chunks with section metadata.")print("\n--- Sample Chunk with Metadata ---")# 為了證明它奏效了，我們找一個我們知道應該在'Risk Factors'章節的塊並打印出來sample_chunk = next(c for c in doc_chunks_with_metadata if"Risk Factors"in c.metadata.get("section", ""))print(sample_chunk)

#### OUTPUT ####Processing document and adding metadata...Identified 22 document sections.Created 381 chunks with section metadata.--- Sample Chunk with Metadata ---Document(│   page_content='Our industry is intensely competitive. We operate in the semiconductor\\nindustry, which is intensely competitive and characterized by rapid\\ntechnological change and evolving industry standards. We compete with a number of\\ncompanies that have different business models and different combinations of\\nhardware, software, and systems expertise, many of which have substantially\\ngreater resources than we have. We expect competition to increase from existing\\ncompetitors, as well as new and emerging companies. Our competitors include\\nIntel, AMD, and Qualcomm; cloud service providers, or CSPs, such as Amazon Web\\nServices, or AWS, Google Cloud, and Microsoft Azure; and various companies\\ndeveloping or that may develop processors or systems for the AI, HPC, data\\ncenter, gaming, professional visualization, and automotive markets. Some of our\\ncustomers are also our competitors. Our business could be materially and\\nadversely affected if our competitors announce or introduce new products, services,\\nor technologies that have better performance or features, are less expensive, or\\nthat gain market acceptance.',│   metadata={│   │   'section': 'Item 1A. Risk Factors.',│   │   'source_doc': './data/nvda_10k_2023_clean.txt',│   │   'id': '...'│   })

class RetrievalDecision(BaseModel):    # 選擇的檢索策略。必須是這三個選項之一。    strategy: Literal["vector_search", "keyword_search", "hybrid_search"]    # 智能體對其選擇的理由。    justification: str

retrieval_supervisor_prompt = ChatPromptTemplate.from_messages([    ("system", """You are a retrieval strategy expert. Based on the user's query, you must decide the best retrieval strategy.You have three options:1. `vector_search`: Best for conceptual, semantic, or similarity-based queries.2. `keyword_search`: Best for queries with specific, exact terms, names, or codes (e.g., 'Item 1A', 'Hopper architecture').3. `hybrid_search`: A good default that combines both, but may be less precise than a targeted strategy."""),    ("human", "User Query: {sub_question}") # 重寫後的搜索查詢將在此處傳遞。])

# 通過將我們的提示傳遞給推理 LLM 並使用我們的 Pydantic 類結構化其輸出來創建智能體retrieval_supervisor_agent = retrieval_supervisor_prompt | reasoning_llm.with_structured_output(RetrievalDecision)print("Retrieval Supervisor Agent created.")# 讓我們用兩種不同類型的查詢來測試它，看看它的行為如何print("\n--- Testing Retrieval Supervisor Agent ---")query1 = "revenue growth for the Compute & Networking segment in fiscal year 2023"decision1 = retrieval_supervisor_agent.invoke({"sub_question": query1})print(f"Query: '{query1}'")print(f"Decision: {decision1.strategy}, Justification: {decision1.justification}")query2 = "general sentiment about market competition and technological innovation"decision2 = retrieval_supervisor_agent.invoke({"sub_question": query2})print(f"\nQuery: '{query2}'")print(f"Decision: {decision2.strategy}, Justification: {decision2.justification}")

#### OUTPUT ####Retrieval Supervisor Agent created.# --- Testing Retrieval Supervisor Agent ---Query: 'revenue growth for the Compute & Networking segment in fiscal year 2023'Decision: keyword_search, Justification: The query contains specific keywords like 'revenue growth', 'Compute & Networking', and 'fiscal year 2023' which are ideal for a keyword-based search to find exact financial figures.Query: 'general sentiment about market competition and technological innovation'Decision: vector_search, Justification: This query is conceptual and seeks to understand sentiment and broader themes. Vector search is better suited to capture the semantic meaning of 'market competition' and 'technological innovation' rather than relying on exact keywords.

import numpy as np # Python 中用於數值運算的基礎庫from rank_bm25 import BM25Okapi # 用於實現 BM25 關鍵詞搜索算法的庫print("Creating advanced vector store with metadata...")# 我們創建一個新的 Chroma 向量存儲，這次使用我們富含元數據的塊advanced_vector_store = Chroma.from_documents(    documents=doc_chunks_with_metadata,    embedding=embedding_function)print(f"Advanced vector store created with {advanced_vector_store._collection.count()} embeddings.")

print("\nBuilding BM25 index for keyword search...")# 創建一個列表，其中每個元素都是來自一個文檔的單詞列表tokenized_corpus = [doc.page_content.split(" ") for doc in doc_chunks_with_metadata]# 創建一個包含所有唯一文檔 ID 的列表doc_ids = [doc.metadata["id"] for doc in doc_chunks_with_metadata]# 創建一個從文檔 ID 到完整 Document 對象的映射，以便於查找doc_map = {doc.metadata["id"]: doc for doc in doc_chunks_with_metadata}# 使用我們的分詞語料庫初始化 BM25Okapi 索引bm25 = BM25Okapi(tokenized_corpus)

# 策略 1: 純向量搜索，帶元數據過濾defvector_search_only(query: str, section_filter: str = None, k: int = 10):    # 這個字典定義了元數據過濾器。ChromaDB 只會搜索匹配此條件的文檔。    filter_dict = {"section": section_filter} if section_filter and"Unknown"notin section_filter elseNone    # 執行相似性搜索，並可選地使用過濾器    return advanced_vector_store.similarity_search(query, k=k, filter=filter_dict)# 策略 2: 純關鍵詞搜索 (BM25)defbm25_search_only(query: str, k: int = 10):    # 對傳入的查詢進行分詞    tokenized_query = query.split(" ")    # 獲取查詢相對於語料庫中所有文檔的 BM25 分數    bm25_scores = bm25.get_scores(tokenized_query)    # 獲取得分最高的 k 個文檔的索引    top_k_indices = np.argsort(bm25_scores)[::-1][:k]    # 使用我們的 doc_map 返回得分最高的文檔的完整 Document 對象    return [doc_map[doc_ids[i]] for i in top_k_indices]# 策略 3: 混合搜索，採用倒數排序融合 (RRF)defhybrid_search(query: str, section_filter: str = None, k: int = 10):    # 1. 執行關鍵詞搜索    bm25_docs = bm25_search_only(query, k=k)    # 2. 執行帶元數據過濾的語義搜索    semantic_docs = vector_search_only(query, section_filter=section_filter, k=k)    # 3. 使用倒數排序融合 (RRF) 合併並重新排序結果    # 獲取兩種搜索方法找到的所有文檔的唯一集合    all_docs = {doc.metadata["id"]: doc for doc in bm25_docs + semantic_docs}.values()    # 從每個搜索結果中創建僅包含文檔 ID 的列表    ranked_lists = [[doc.metadata["id"] for doc in bm25_docs], [doc.metadata["id"] for doc in semantic_docs]]        # 初始化一個字典來存儲每個文檔的 RRF 分數    rrf_scores = {}    # 遍歷每個排名列表（BM25 和語義搜索）    for doc_list in ranked_lists:        # 遍歷列表中的每個文檔 ID 及其排名 (i)        for i, doc_id inenumerate(doc_list):            if doc_id notin rrf_scores:                rrf_scores[doc_id] = 0            # RRF 公式：將 1 / (排名 + k) 加到分數上。我們使用 k=61 作為標準默認值。            rrf_scores[doc_id] += 1 / (i + 61)     # 根據它們的最終 RRF 分數按降序對文檔 ID 進行排序    sorted_doc_ids = sorted(rrf_scores.keys(), key=lambda x: rrf_scores[x], reverse=True)    # 根據融合後的排名返回前 k 個 Document 對象    final_docs = [doc_map[doc_id] for doc_id in sorted_doc_ids[:k]]    return final_docsprint("\nAll retrieval strategy functions ready.")

# 測試關鍵詞搜索，看它是否能精確找到特定章節print("\n--- Testing Keyword Search ---")test_query = "Item 1A. Risk Factors"test_results = bm25_search_only(test_query)print(f"Query: {test_query}")print(f"Found {len(test_results)} documents. Top result section: {test_results[0].metadata['section']}")
``````plaintext
#### OUTPUT ####Creating advanced vector store with metadata...Advanced vector store created with 381 embeddings.Building BM25 index for keyword search...All retrieval strategy functions ready.# --- Testing Keyword Search ---Query: Item 1A. Risk FactorsFound 10 documents. Top result section: Item 1A. Risk Factors.

from sentence_transformers import CrossEncoder # 使用交叉編碼器模型的庫print("Initializing CrossEncoder reranker...")# 使用我們中央配置字典中的名稱初始化 CrossEncoder 模型。# 如果模型沒有被緩存，庫將自動從 Hugging Face Hub 下載。reranker = CrossEncoder(config["reranker_model"])

def rerank_documents_function(query: str, documents: List[Document]) -> List[Document]:    # 如果沒有文檔需要重排序，立即返回一個空列表。    ifnot documents:         return []            # 創建交叉編碼器所需的 [查詢, 文檔內容] 對。    pairs = [(query, doc.page_content) for doc in documents]        # 使用重排序器為每個對預測一個相關性分數。這將返回一個分數列表。    scores = reranker.predict(pairs)        # 將原始文檔與它們的新分數結合起來。    doc_scores = list(zip(documents, scores))        # 根據分數按降序對 (文檔, 分數) 元組列表進行排序。    doc_scores.sort(key=lambda x: x[1], reverse=True)        # 從排序後的前 N 個結果中僅提取 Document 對象。    # 要保留的文檔數量由我們配置中的 'top_n_rerank' 控制。    reranked_docs = [doc for doc, score in doc_scores[:config["top_n_rerank"]]]        return reranked_docs

# 我們蒸餾智能體的提示，指示它進行綜合並保持簡潔distiller_prompt = ChatPromptTemplate.from_messages([    ("system", """You are a helpful assistant. Your task is to synthesize the following retrieved document snippets into a single, concise paragraph.The goal is to provide a clear and coherent context that directly answers the question: '{question}'.Focus on removing redundant information and organizing the content logically. Answer only with the synthesized context."""),    ("human", "Retrieved Documents:\n{context}") # 我們排名前 3 的重排序文檔內容將在此處傳遞])

# 通過將我們的提示管道連接到推理 LLM 和一個字符串輸出解析器來創建智能體distiller_agent = distiller_prompt | reasoning_llm | StrOutputParser()print("Contextual Distiller Agent created.")

from langchain_community.tools.tavily_search import TavilySearchResults# 初始化 Tavily 搜索工具。# k=3: 這個參數指示工具為給定的查詢返回前 3 個最相關的搜索結果。web_search_tool = TavilySearchResults(k=3)

def web_search_function(query: str) -> List[Document]:    # 使用提供的查詢調用 Tavily 搜索工具。    results = web_search_tool.invoke({"query": query})        # 將結果格式化為 LangChain Document 對象的列表。    # 我們使用列表推導式以實現簡潔易讀的實現。    return [        Document(            # 搜索結果的主要內容放入 'page_content'。            page_content=res["content"],            # 我們將源 URL 存儲在 'metadata' 字典中以便引用。            metadata={"source": res["url"]}        ) for res in results    ]

# 使用關於 AMD 2024 年戰略的查詢測試網絡搜索功能print("\n--- Testing Web Search Tool ---")test_query_web = "AMD AI chip strategy 2024"test_results_web = web_search_function(test_query_web)print(f"Found {len(test_results_web)} results for query: '{test_query_web}'")# 打印第一個結果的片段，看看我們得到了什麼if test_results_web:    print(f"Top result snippet: {test_results_web[0].page_content[:250]}...")
``````plaintext
#### OUTPUT ####Web search tool (Tavily) initialized.--- Testing Web Search Tool ---Found 3 results for query: 'AMD AI chip strategy 2024'Top result snippet: AMD has intensified its battle with Nvidia in the AI chip market with the release of the Instinct MI300X accelerator, a powerful GPU designed to challenge Nvidia's H100 in training and inference for large language models. Major cloud providers like Microsoft Azure and Oracle Cloud are adopting the MI300X, indicating strong market interest...

# 我們反思智能體的提示，指示它要簡潔和事實。reflection_prompt = ChatPromptTemplate.from_messages([    ("system", """You are a research assistant. Based on the retrieved context for the current sub-question, write a concise, one-sentence summary of the key findings.This summary will be added to our research history. Be factual and to the point."""),    ("human", "Current sub-question: {sub_question}\n\nDistilled context:\n{context}")])

# 通過將我們的提示管道連接到推理 LLM 和一個字符串輸出解析器來創建智能體reflection_agent = reflection_prompt | reasoning_llm | StrOutputParser()print("Reflection Agent created.")

class Decision(BaseModel):    # 決策必須是這兩個動作之一。    next_action: Literal["CONTINUE_PLAN", "FINISH"]    # 智能體必須為其決策提供理由。    justification: str

# 我們策略智能體的提示，指示它扮演總策略師的角色policy_prompt = ChatPromptTemplate.from_messages([    ("system", """You are a master strategist. Your role is to analyze the research progress and decide the next action.You have the original question, the initial plan, and a log of completed steps with their summaries.- If the collected information in the Research History is sufficient to comprehensively answer the Original Question, decide to FINISH.- Otherwise, if the plan is not yet complete, decide to CONTINUE_PLAN."""),    ("human", "Original Question: {question}\n\nInitial Plan:\n{plan}\n\nResearch History (Completed Steps):\n{history}")])

# 通過將我們的提示管道連接到推理 LLM 並使用我們的 Decision 類來結構化其輸出來創建智能體policy_agent = policy_prompt | reasoning_llm.with_structured_output(Decision)print("Policy Agent created.")# 現在，讓我們用我們研究過程的兩種不同狀態來測試策略智能體print("\n--- Testing Policy Agent (Incomplete State) ---")# 首先，一個只完成了步驟 1 的狀態。plan_str = json.dumps([s.dict() for s in test_plan.steps])incomplete_history = "Step 1 Summary: NVIDIA's 10-K states that the semiconductor industry is intensely competitive and subject to rapid technological change."decision1 = policy_agent.invoke({"question": complex_query_adv, "plan": plan_str, "history": incomplete_history})print(f"Decision: {decision1.next_action}, Justification: {decision1.justification}")print("\n--- Testing Policy Agent (Complete State) ---")# 其次，一個步驟 1 和步驟 2 都已完成的狀態。complete_history = incomplete_history + "\nStep 2 Summary: In 2024, AMD launched its MI300X accelerator to directly compete with NVIDIA in the AI chip market, gaining adoption from major cloud providers."decision2 = policy_agent.invoke({"question": complex_query_adv, "plan": plan_str, "history": complete_history})print(f"Decision: {decision2.next_action}, Justification: {decision2.justification}")

#### OUTPUT ####Policy Agent created.--- Testing Policy Agent (Incomplete State) ---Decision: CONTINUE_PLAN, Justification: The research has only identified NVIDIA's competitive risks from the 10-K. It has not yet gathered the required external information about AMD's 2024 strategy, which is the next step in the plan.--- Testing Policy Agent (Complete State) ---Decision: FINISH, Justification: The research history now contains comprehensive summaries of both NVIDIA's stated competitive risks and AMD's recent AI chip strategy. All necessary information has been gathered to perform the final synthesis and answer the user's question.

# 一個輔助函數，用於為提示格式化研究歷史def get_past_context_str(past_steps: List[PastStep]) -> str:    # 這將 PastStep 字典列表連接成一個單一的字符串。    # 每個步驟都清楚地標記出來，以便 LLM 理解上下文。    return "\\n\\n".join([f"Step {s['step_index']}: {s['sub_question']}\\nSummary: {s['summary']}" for s in past_steps])

# 節點 1: 規劃器def plan_node(state: RAGState) -> Dict:    console.print("--- 🧠: Generating Plan ---")    # 我們調用之前創建的 planner_agent，傳入用户的原始問題。    plan = planner_agent.invoke({"question": state["original_question"]})    rprint(plan)    # 我們返回一個包含我們 RAGState 更新的字典。    # LangGraph 會自動將這個合併到主狀態中。    return {"plan": plan, "current_step_index": 0, "past_steps": []}

# 節點 2a: 從 10-K 文檔中檢索defretrieval_node(state: RAGState) -> Dict:    # 首先，獲取計劃中當前步驟的詳細信息。    current_step_index = state["current_step_index"]    current_step = state["plan"].steps[current_step_index]    console.print(f"--- 🔍: Retrieving from 10-K (Step {current_step_index + 1}: {current_step.sub_question}) ---")        # 使用我們的查詢重寫器來優化用於搜索的子問題。    past_context = get_past_context_str(state['past_steps'])    rewritten_query = query_rewriter_agent.invoke({        "sub_question": current_step.sub_question,        "keywords": current_step.keywords,        "past_context": past_context    })    console.print(f"  Rewritten Query: {rewritten_query}")        # 獲取監督器關於哪個檢索策略最好的決定。    retrieval_decision = retrieval_supervisor_agent.invoke({"sub_question": rewritten_query})    console.print(f"  Supervisor Decision: Use `{retrieval_decision.strategy}`. Justification: {retrieval_decision.justification}")    # 根據決定，執行正確的檢索函數。    if retrieval_decision.strategy == 'vector_search':        retrieved_docs = vector_search_only(rewritten_query, section_filter=current_step.document_section, k=config['top_k_retrieval'])    elif retrieval_decision.strategy == 'keyword_search':        retrieved_docs = bm25_search_only(rewritten_query, k=config['top_k_retrieval'])    else: # hybrid_search        retrieved_docs = hybrid_search(rewritten_query, section_filter=current_step.document_section, k=config['top_k_retrieval'])        # 返回檢索到的文檔以添加到狀態中。    return {"retrieved_docs": retrieved_docs}

# 節點 2b: 從網絡檢索defweb_search_node(state: RAGState) -> Dict:    # 獲取當前步驟的詳細信息。    current_step_index = state["current_step_index"]    current_step = state["plan"].steps[current_step_index]    console.print(f"--- 🌐: Searching Web (Step {current_step_index + 1}: {current_step.sub_question}) ---")        # 為網絡搜索引擎重寫子問題。    past_context = get_past_context_str(state['past_steps'])    rewritten_query = query_rewriter_agent.invoke({        "sub_question": current_step.sub_question,        "keywords": current_step.keywords,        "past_context": past_context    })    console.print(f"  Rewritten Query: {rewritten_query}")    # 調用我們的網絡搜索函數。    retrieved_docs = web_search_function(rewritten_query)    # 返回結果。    return {"retrieved_docs": retrieved_docs}

# 節點 3: 重排序器def rerank_node(state: RAGState) -> Dict:    console.print("--- 🎯: Reranking Documents ---")    # 獲取當前步驟的詳細信息。    current_step_index = state["current_step_index"]    current_step = state["plan"].steps[current_step_index]    # 對我們剛剛檢索到的文檔調用我們的重排序函數。    reranked_docs = rerank_documents_function(current_step.sub_question, state["retrieved_docs"])    console.print(f"  Reranked to top {len(reranked_docs)} documents.")    # 用高精度文檔更新狀態。    return {"reranked_docs": reranked_docs}

# 節點 4: 壓縮器 / 蒸餾器def compression_node(state: RAGState) -> Dict:    console.print("--- ✂️: Distilling Context ---")    # 獲取當前步驟的詳細信息。    current_step_index = state["current_step_index"]    current_step = state["plan"].steps[current_step_index]    # 將前 3 份文檔格式化為單個字符串。    context = format_docs(state["reranked_docs"])    # 調用我們的蒸餾器智能體將它們綜合成一個段落。    synthesized_context = distiller_agent.invoke({"question": current_step.sub_question, "context": context})    console.print(f"  Distilled Context Snippet: {synthesized_context[:200]}...")    # 用最終的、乾淨的上下文更新狀態。    return {"synthesized_context": synthesized_context}

# 節點 5: 反思 / 更新步驟defreflection_node(state: RAGState) -> Dict:    console.print("--- 🤔: Reflecting on Findings ---")    # 獲取當前步驟的詳細信息。    current_step_index = state["current_step_index"]    current_step = state["plan"].steps[current_step_index]    # 調用我們的反思智能體來總結髮現。    summary = reflection_agent.invoke({"sub_question": current_step.sub_question, "context": state['synthesized_context']})    console.print(f"  Summary: {summary}")        # 創建一個包含此步驟所有結果的新 PastStep 字典。    new_past_step = {        "step_index": current_step_index + 1,        "sub_question": current_step.sub_question,        "retrieved_docs": state['reranked_docs'], # 我們保存重排序後的文檔以供最終引用        "summary": summary    }    # 將新步驟附加到我們的歷史中，並增加步驟索引以移至下一步。    return {"past_steps": state["past_steps"] + [new_past_step], "current_step_index": current_step_index + 1}

# 節點 6: 最終答案生成器deffinal_answer_node(state: RAGState) -> Dict:    console.print("--- ✅: Generating Final Answer with Citations ---")    # 首先，我們需要收集我們從所有過去步驟中收集到的所有證據。    final_context = ""    for i, step inenumerate(state['past_steps']):        final_context += f"\\n--- Findings from Research Step {i+1} ---\\n"        # 我們包含每個文檔的來源元數據（章節或 URL）以啓用引用。        for doc in step['retrieved_docs']:            source = doc.metadata.get('section') or doc.metadata.get('source')            final_context += f"Source: {source}\\nContent: {doc.page_content}\\n\\n"        # 我們創建一個專門用於生成最終、可引用答案的新提示。    final_answer_prompt = ChatPromptTemplate.from_messages([        ("system", """You are an expert financial analyst. Synthesize the research findings from internal documents and web searches into a comprehensive, multi-paragraph answer for the user's original question.Your answer must be grounded in the provided context. At the end of any sentence that relies on specific information, you MUST add a citation. For 10-K documents, use [Source: <section title>]. For web results, use [Source: <URL>]."""),        ("human", "Original Question: {question}\n\nResearch History and Context:\n{context}")    ])        # 我們為這個最終任務創建一個臨時智能體並調用它。    final_answer_agent = final_answer_prompt | reasoning_llm | StrOutputParser()    final_answer = final_answer_agent.invoke({"question": state['original_question'], "context": final_context})    # 用最終答案更新狀態。    return {"final_answer": final_answer}

# 條件邊 1: 工具路由器def route_by_tool(state: RAGState) -> str:    # 獲取我們當前所處步驟的索引。    current_step_index = state["current_step_index"]    # 從計劃中獲取當前步驟的完整詳情。    current_step = state["plan"].steps[current_step_index]    # 返回為此步驟指定的工具名稱。    # LangGraph 將使用這個字符串來決定下一個要去的節點。    return current_step.tool

# 條件邊 2: 主控制循環defshould_continue_node(state: RAGState) -> str:    console.print("--- 🚦: Evaluating Policy ---")    # 獲取我們即將開始的步驟的索引。    current_step_index = state["current_step_index"]        # 首先，檢查我們的基本停止條件。    # 條件 1: 我們是否已完成計劃中的所有步驟？    if current_step_index >= len(state["plan"].steps):        console.print("  -> Plan complete. Finishing.")        return"finish"        # 條件 2: 我們是否已超過我們設定的迭代次數安全限制？    if current_step_index >= config["max_reasoning_iterations"]:        console.print("  -> Max iterations reached. Finishing.")        return"finish"    # 一個特例：如果上一步的檢索未能找到任何文檔，    # 那麼進行反思就沒有意義了。最好直接進入下一步。    if state.get("reranked_docs") isnotNoneandnot state["reranked_docs"]:        console.print("  -> Retrieval failed for the last step. Continuing with next step in plan.")        return"continue"    # 如果沒有滿足任何基本條件，就該詢問我們的策略智能體了。    # 我們將歷史和計劃格式化為字符串以用於提示。    history = get_past_context_str(state['past_steps'])    plan_str = json.dumps([s.dict() for s in state['plan'].steps])    # 調用策略智能體以獲取其戰略決策。    decision = policy_agent.invoke({"question": state["original_question"], "plan": plan_str, "history": history})    console.print(f"  -> Decision: {decision.next_action} | Justification: {decision.justification}")        # 根據智能體的決策，返回適當的信號。    if decision.next_action == "FINISH":        return"finish"    else: # CONTINUE_PLAN        return "continue"

from langgraph.graph import StateGraph, END # 導入主要的圖組件# 實例化圖，告訴它使用我們的 RAGState TypedDict 作為其狀態模式。graph = StateGraph(RAGState)

# 將我們所有的 Python 函數添加為圖中的節點graph.add_node("plan", plan_node)                     # 創建初始計劃的節點graph.add_node("retrieve_10k", retrieval_node)        # 內部文檔檢索的節點graph.add_node("retrieve_web", web_search_node)       # 外部網絡搜索的節點graph.add_node("rerank", rerank_node)                 # 執行精確重排序的節點graph.add_node("compress", compression_node)          # 蒸餾上下文的節點graph.add_node("reflect", reflection_node)            # 總結髮現並更新歷史的節點graph.add_node("generate_final_answer", final_answer_node) # 綜合最終答案的節點

# 我們圖的入口點是 "plan" 節點。每次運行都從這裏開始。graph.set_entry_point("plan")# 在 "plan" 節點之後，我們使用我們的第一個條件邊來決定使用哪個工具。graph.add_conditional_edges(    "plan",           # 源節點    route_by_tool,    # 做出決策的函數    {                 # 一個將函數輸出字符串映射到目標節點的字典        "search_10k": "retrieve_10k",        "search_web": "retrieve_web",    },)# 從 10-K 或網絡檢索之後，流程在一段時間內是線性的。graph.add_edge("retrieve_10k", "rerank") # 內部檢索後，總是轉到重排序。graph.add_edge("retrieve_web", "rerank") # 網絡檢索後，也總是轉到重排序。graph.add_edge("rerank", "compress")      # 重排序後，總是轉到壓縮。graph.add_edge("compress", "reflect")     # 壓縮後，總是轉到反思。# 在 "reflect" 節點之後，我們遇到我們的主條件邊，它控制着推理循環。graph.add_conditional_edges(    "reflect",        # 源節點    should_continue_node, # 調用我們策略智能體的函數    {                 # 一個將決策映射到下一步的字典        "continue": "plan", # 如果決策是 "continue"，我們循環回到 "plan" 節點以路由下一步。        "finish": "generate_final_answer", # 如果決策是 "finish"，我們繼續生成最終答案。    },)# "generate_final_answer" 節點是結束前的最後一步。graph.add_edge("generate_final_answer", END) # 生成答案後，圖結束。print("StateGraph constructed successfully.")

# .compile() 方法接收我們的圖定義並創建一個可運行的對象。deep_thinking_rag_graph = graph.compile()print("Graph compiled successfully.")# 現在，讓我們可視化我們構建的架構。try:    from IPython.display import Image, display    # 我們可以得到圖結構的 PNG 圖像。    png_image = deep_thinking_rag_graph.get_graph().draw_png()    # 在我們的 notebook 中顯示圖像。    display(Image(png_image))except Exception as e:    # 如果 pygraphviz 及其系統依賴項未安裝，這可能會失敗。    print(f"Graph visualization failed: {e}. Please ensure pygraphviz is installed.")

# 這將保存運行完成後圖的最終狀態。final_state = None# 我們圖的初始輸入，包含原始用户查詢。graph_input = {"original_question": complex_query_adv}print("--- Invoking Deep Thinking RAG Graph ---")# 我們使用 .stream() 來實時觀察智能體的過程。# "values" 模式意味着我們在每一步之後都會得到完整的 RAGState 對象。for chunk in deep_thinking_rag_graph.stream(graph_input, stream_mode="values"):    # 流中的最後一個塊將是圖的最終狀態。    final_state = chunkprint("\n--- Graph Stream Finished ---")

#### OUTPUT ####--- Invoking Deep Thinking RAG Graph ------ 🧠: Generating Plan ---plan:  steps:  - sub_question: What are the key risks related to competition as stated in NVIDIA's 2023 10-K filing?    tool: search_10k    ...  - sub_question: What are the recent news and developments in AMD's AI chip strategy in2024?    tool: search_web    ...--- 🔍: Retrieving from10-K (Step 1: ...) ---  Rewritten Query: key competitive risks for NVIDIA in the semiconductor industry...  Supervisor Decision: Use `hybrid_search`. ...--- 🎯: Reranking Documents ---  Reranked to top 3 documents.--- ✂️: Distilling Context ---  Distilled Context Snippet: NVIDIA operates in the intensely competitive semiconductor industry...--- 🤔: Reflecting on Findings ---  Summary: According to its 202310-K, NVIDIA operates in an intensely competitive semiconductor industry...--- 🚦: Evaluating Policy ---  -> Decision: CONTINUE_PLAN | Justification: The first step...has been completed. The next step...is still pending...--- 🌐: Searching Web (Step 2: ...) ---  Rewritten Query: AMD AI chip strategy news and developments 2024...--- 🎯: Reranking Documents ---  Reranked to top 3 documents.--- ✂️: Distilling Context ---  Distilled Context Snippet: AMD has ramped up its challenge to Nvidia in the AI accelerator market with its Instinct MI300 series...--- 🤔: Reflecting on Findings ---  Summary: In 2024, AMD is aggressively competing with NVIDIA in the AI chip market through its Instinct MI300X accelerator...--- 🚦: Evaluating Policy ---  -> Decision: FINISH | Justification: The research history now contains comprehensive summaries of both NVIDIA's stated risks and AMD's recent strategy...--- ✅: Generating Final Answer with Citations ------ Graph Stream Finished ---

console.print("--- DEEP THINKING RAG FINAL ANSWER ---")console.print(Markdown(final_state['final_answer']))
``````plaintext
#### OUTPUT ####--- DEEP THINKING RAG FINAL ANSWER ---Based on an analysis of NVIDIA's 2023 10-K filing and recent news from 2024 regarding AMD's AI chip strategy, the following synthesis can be made:**NVIDIA's Stated Competitive Risks:**In its 2023 10-K filing, NVIDIA identifies its operating environment as the "intensely competitive" semiconductor industry, which is characterized by rapid technological change. A primary risk is that competitors, including AMD, could introduce new products with better performance or lower costs that gain significant market acceptance, which could materially and adversely affect its business [Source: Item 1A. Risk Factors.].**AMD's 2024 AI Chip Strategy:**In 2024, AMD has moved aggressively to challenge NVIDIA's dominance in the AI hardware market with its Instinct MI300 series of accelerators, particularly the MI300X. This product is designed to compete directly with NVIDIA's H100 GPU. AMD's strategy has gained significant traction, with major cloud providers such as Microsoft Azure and Oracle announcing plans to use the new chips [Source: https://www.reuters.com/technology/amd-forecasts-35-billion-ai-chip-revenue-2024-2024-01-30/].**Synthesis and Impact:**AMD's 2024 AI chip strategy directly exacerbates the competitive risks outlined in NVIDIA's 10-K. The successful launch and adoption of the MI300X is a materialization of the specific risk that a competitor could introduce a product with comparable performance. The adoption of AMD's chips by major cloud providers signifies a direct challenge to NVIDIA's market share in the lucrative data center segment, validating NVIDIA's stated concerns about rapid technological change [Source: Item 1A. Risk Factors. and https://www.cnbc.com/2023/12/06/amd-launches-new-mi300x-ai-chip-to-compete-with-nvidias-h100.html].

from datasets import Dataset # 來自 Hugging Face datasets 庫，RAGAs 使用它from ragas import evaluatefrom ragas.metrics import (    context_precision,    context_recall,    faithfulness,    answer_correctness,)import pandas as pdprint("Preparing evaluation dataset...")# 這是我們手動製作的，對複雜查詢的理想答案。ground_truth_answer_adv = "NVIDIA's 2023 10-K lists intense competition and rapid technological change as key risks. This risk is exacerbated by AMD's 2024 strategy, specifically the launch of the MI300X AI accelerator, which directly competes with NVIDIA's H100 and has been adopted by major cloud providers, threatening NVIDIA's market share in the data center segment."# 我們需要為基線模型重新運行檢索器，以獲取其用於評估的上下文。retrieved_docs_for_baseline_adv = baseline_retriever.invoke(complex_query_adv)baseline_contexts = [[doc.page_content for doc in retrieved_docs_for_baseline_adv]]# 對於高級智能體，我們將整合它在所有研究步驟中檢索到的所有文檔。advanced_contexts_flat = []for step in final_state['past_steps']:    advanced_contexts_flat.extend([doc.page_content for doc in step['retrieved_docs']])# 我們使用一個集合來移除任何重複的文檔，以進行更清晰的評估。advanced_contexts = [list(set(advanced_contexts_flat))]# 現在，我們構建將轉變為我們評估數據集的字典。eval_data = {    'question': [complex_query_adv, complex_query_adv], # 兩個系統使用相同的問題    'answer': [baseline_result, final_state['final_answer']], # 每個系統給出的答案    'contexts': baseline_contexts + advanced_contexts, # 每個系統使用的上下文    'ground_truth': [ground_truth_answer_adv, ground_truth_answer_adv] # 理想答案}# 創建 Hugging Face Dataset 對象。eval_dataset = Dataset.from_dict(eval_data)# 定義我們想要計算的指標列表。metrics = [    context_precision,    context_recall,    faithfulness,    answer_correctness,]print("Running RAGAs evaluation...")# 運行評估。RAGAs 將調用一個 LLM 來為每個指標進行評分。result = evaluate(eval_dataset, metrics=metrics, is_async=False)print("Evaluation complete.")# 將結果格式化為一個乾淨的 pandas DataFrame，以便於比較。results_df = result.to_pandas()results_df.index = ['baseline_rag', 'deep_thinking_rag']print("\n--- RAGAs Evaluation Results ---")print(results_df[['context_precision', 'context_recall', 'faithfulness', 'answer_correctness']].T)

#### OUTPUT ####Preparing evaluation dataset...Running RAGAs evaluation...Evaluation complete.--- RAGAs Evaluation Results ---                     baseline_rag  deep_thinking_ragcontext_precision        0.500000           0.890000context_recall           0.333333           1.000000faithfulness             1.000000           1.000000answer_correctness       0.395112           0.991458