RAG 2.0: 企業知識管理の革新 - シンプルなチャットボットを超えて

ユーザー質問
  ↓
ベクトルデータベースで類似ドキュメントを検索
  ↓
検索されたドキュメント + 質問をプロンプトに含める
  ↓
LLMが答えを生成

ユーザー質問
  ├─→ キーワード検索 (BM25)
  ├─→ ベクトル検索 (意味的)
  ├─→ 知識グラフクエリ (関係ベース)
  ├─→ メタデータフィルタリング (属性ベース)
  └─→ 再ランク付けと統合
        ↓
      豊富な文脈を持つ検索結果
        ↓
      LLMが引用付きで答えを生成

from weaviate import Client
from weaviate.auth import AuthApiKey
import os

client = Client(
    url="https://your-cluster.weaviate.network",
    auth_client_secret=AuthApiKey(api_key=os.environ["WEAVIATE_API_KEY"])
)

def hybrid_search(query, query_type="documents"):
    # ハイブリッド検索: BM25 (キーワード) + ベクトル (意味的)
    response = client.query\
        .get(query_type, ["title", "content", "source", "confidence"])\
        .with_hybrid(query=query, alpha=0.7)\
        .with_where({
            "path": ["createdAt"],
            "operator": "GreaterThan",
            "valueDate": "2024-01-01T00:00:00Z"
        })\
        .with_limit(10)\
        .do()

    return response["data"]["Get"][query_type]

# 使用例
results = hybrid_search("2026年第1四半期の売上予測")
for result in results:
    print(f"ドキュメント: {result['title']}")
    print(f"確信度: {result['confidence']}")
    print(f"ソース: {result['source']}\n")

エンティティ (ノード):
  - 企業: "Acme株式会社"
  - 部門: "エンジニアリング", "営業", "財務"
  - 製品: "製品A", "製品B"
  - 人: "田中太郎", "佐藤花子"

関係 (エッジ):
  - "Acme株式会社" --管理--> "エンジニアリング"
  - "エンジニアリング" --構築--> "製品A"
  - "佐藤花子" --リード--> "エンジニアリング"
  - "田中太郎" --監督--> "製品A"

MATCH (company:Company {name: "Acme株式会社"})-[:manages]->(dept:Department)
      -[:builds]->(product:Product),
      (person:Person)-[:leads]->(dept)
WHERE product.status = "Active"
RETURN company.name, dept.name, product.name, person.name
ORDER BY product.launchDate DESC

from langchain.document_loaders import PDFPlumberLoader
from langchain.chat_models import ChatOpenAI
from langchain.schema import HumanMessage, SystemMessage
import base64

def process_multimodal_documents(pdf_path):
    loader = PDFPlumberLoader(pdf_path)
    documents = loader.load()

    multimodal_content = []

    for doc in documents:
        # テキストを抽出
        text_content = doc.page_content

        # 画像と表を抽出
        images = doc.metadata.get('images', [])
        tables = doc.metadata.get('tables', [])

        multimodal_content.append({
            'type': 'text',
            'content': text_content
        })

        for img in images:
            multimodal_content.append({
                'type': 'image',
                'content': img
            })

        for table in tables:
            multimodal_content.append({
                'type': 'table',
                'content': table
            })

    return multimodal_content

# GPT-4Vを使用したマルチモーダル分析
def analyze_with_vision(multimodal_content):
    client = ChatOpenAI(model="gpt-4-vision-preview")

    messages = [
        SystemMessage(content="あなたは企業ドキュメント分析の専門家です。提供されたテキスト、画像、表を包括的に分析してください。"),
        HumanMessage(
            content=[
                {
                    "type": "text",
                    "text": "このドキュメントで最も重要な財務指標は何ですか?"
                },
                *[{"type": item['type'], "data": item['content']}
                  for item in multimodal_content[:3]]
            ]
        )
    ]

    response = client.invoke(messages)
    return response.content

┌─────────────────────────────────────────────────┐
│      ユーザーインターフェースレイヤー             │
│  (ウェブ、モバイル、音声、Slack、Teams)         │
└──────────────┬──────────────────────────────────┘
               │
┌──────────────▼──────────────────────────────────┐
│     オーケストレーション / エージェントレイヤー   │
│  (LangChain / LlamaIndex エージェント)          │
└──────────────┬──────────────────────────────────┘
               │
      ┌────────┼────────┐
      │        │        │
┌─────▼──┐ ┌──▼────┐ ┌─▼──────┐
│LLM    │ │検索   │ │ツール  │
│エンジン│ │エンジン│ │プラグイン
└────────┘ └───────┘ └────────┘
      │        │        │
      └────────┼────────┘
               │
      ┌────────▼────────────────┐
      │     データレイヤー        │
      │                         │
      │ ┌─────────────────────┐ │
      │ │ベクトルDB (Pinecone)│ │
      │ │キーワード (ES)      │ │
      │ │グラフDB (Neo4j)     │ │
      │ │メタデータ (SQL)     │ │
      │ └─────────────────────┘ │
      │                         │
      │ ┌─────────────────────┐ │
      │ │ドキュメントソース    │ │
      │ │ - 内部wiki         │ │
      │ │ - メールアーカイブ  │ │
      │ │ - レポートライブラリ│
      │ │ - リアルタイムデータ│
      │ └─────────────────────┘ │
      └──────────────────────────┘

from llama_index.core import Document, VectorStoreIndex
from llama_index.vector_stores.weaviate import WeaviateVectorStore
from llama_index.core.storage import StorageContext
from llama_index.embeddings.openai import OpenAIEmbedding
import weaviate

# Weaviateクライアントを設定
client = weaviate.Client("http://localhost:8080")

# ベクトルストアを設定
vector_store = WeaviateVectorStore(client=client)
storage_context = StorageContext.from_defaults(vector_store=vector_store)
embed_model = OpenAIEmbedding()

# ドキュメントを読み込んでインデックス化
documents = [
    Document(
        text="2026年の第1四半期売上: 50億円、第2四半期: 52億円、第3四半期: 48億円、第4四半期: 55億円の見通し。",
        metadata={"source": "財務計画_2026", "department": "財務", "date": "2026-03-16"}
    ),
    Document(
        text="新製品発売は4月15日に予定されており、1000万円のマーケティング予算が配分されています。",
        metadata={"source": "製品ロードマップ", "department": "マーケティング", "date": "2026-03-01"}
    )
]

# メタデータフィルタリング付きのインデックスを作成
index = VectorStoreIndex.from_documents(
    documents,
    storage_context=storage_context,
    embed_model=embed_model
)

# クエリエンジンを作成
query_engine = index.as_query_engine(
    filters={
        "where": {
            "path": ["metadata.department"],
            "operator": "Equal",
            "valueString": "財務"
        }
    }
)

response = query_engine.query("四半期の売上予測は?")
print(response)

from langchain.agents import Tool, initialize_agent, AgentType
from langchain.chat_models import ChatOpenAI
from langchain.vectorstores import Pinecone
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.memory import ConversationBufferMemory
import pinecone

# Pineconeを初期化
pinecone.init(api_key="YOUR_API_KEY", environment="YOUR_ENV")
index = pinecone.Index("knowledge-base")

# ベクトルストアを設定
embeddings = OpenAIEmbeddings()
vectorstore = Pinecone(index, embeddings.embed_query, "text")

# 検索ツールを定義
def search_knowledge_base(query):
    results = vectorstore.similarity_search(query, k=5)
    return "\n".join([doc.page_content for doc in results])

# ビジネスルールツールを定義
def check_business_rules(query):
    rules = {
        "割引上限": "最大20%の割引が許可されています",
        "最小契約金": "最小契約金は100万円です",
        "承認閾値": "500万円以上ではCFOの承認が必要です"
    }
    for rule, value in rules.items():
        if rule.lower() in query.lower():
            return value
    return "該当するビジネスルールが見つかりません。"

# ツールを登録
tools = [
    Tool(
        name="Knowledge Base Search",
        func=search_knowledge_base,
        description="組織のナレッジベースから関連情報を検索します。"
    ),
    Tool(
        name="Business Rules",
        func=check_business_rules,
        description="ビジネスポリシーおよびルールを確認します。"
    )
]

# エージェントを初期化
memory = ConversationBufferMemory(memory_key="chat_history")
llm = ChatOpenAI(temperature=0, model="gpt-4")

agent = initialize_agent(
    tools,
    llm,
    agent=AgentType.OPENAI_FUNCTIONS,
    memory=memory,
    verbose=True
)

# エージェントを実行
response = agent.run(
    "この顧客に15%の割引を提供できますか? "
    "当社のディスカウント政策は何ですか?"
)
print(response)

from ragas.metrics import (
    context_precision,
    context_recall,
    faithfulness,
    answer_relevancy
)
from ragas import evaluate

# 評価データセット
eval_dataset = {
    "question": [
        "2026年の第1四半期から第4四半期の売上予測は?",
        "新製品発売時期は?",
        "マーケティング予算は?"
    ],
    "ground_truth": [
        "50億円、52億円、48億円、55億円",
        "2026年4月15日",
        "1000万円"
    ],
    "answer": [
        # RAGシステムの回答
    ],
    "contexts": [
        # 検索されたコンテキスト
    ]
}

# RAGAS評価
results = evaluate(
    eval_dataset,
    metrics=[
        context_precision,      # 検索されたドキュメントの関連性
        context_recall,         # 必要な情報が含まれているかどうか
        faithfulness,          # コンテキストへの答えの準拠
        answer_relevancy       # 質問への答えの関連性
    ]
)

print(f"Context Precision: {results['context_precision']:.3f}")
print(f"Context Recall: {results['context_recall']:.3f}")
print(f"Faithfulness: {results['faithfulness']:.3f}")
print(f"Answer Relevancy: {results['answer_relevancy']:.3f}")

def expand_query(original_query):
    expansion_prompt = f"""
    この質問を3つの異なる方法で言い換えてください:
    元の質問: {original_query}

    別の表現:
    """
    # LLMを使用したクエリ拡張
    expanded = llm.invoke(expansion_prompt)
    return [original_query] + expanded.split('\n')

from sentence_transformers import CrossEncoder

cross_encoder = CrossEncoder('cross-encoder/ms-marco-MiniLM-L-6-v2')

def rerank_results(query, candidates):
    pairs = [[query, doc] for doc in candidates]
    scores = cross_encoder.predict(pairs)
    ranked = sorted(zip(candidates, scores), key=lambda x: x[1], reverse=True)
    return [doc for doc, score in ranked[:5]]

Diagram showing RAG 2.0 architecture with hybrid search (keyword and vector paths), knowledge graphs, multiple data sources, and LLM integration. Include icons for different data types (documents, tables, images), vector/graph databases, and the final response generation. Modern tech illustration style with blues and purples.