RAG 2.0: Enterprise Knowledge Management Beyond Chatbots

User Question
  ↓
Search vector database for similar documents
  ↓
Include retrieved documents + question in prompt
  ↓
LLM generates answer

User Question
  ├─→ Keyword Search (BM25)
  ├─→ Vector Search (semantic)
  ├─→ Knowledge Graph Query (relationship-based)
  ├─→ Metadata Filtering (attribute-based)
  └─→ Re-ranking and Fusion
        ↓
      Search results with rich context
        ↓
      LLM generates answer with citations

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"):
    # Hybrid search: BM25 (keyword) + vector (semantic)
    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]

# Usage
results = hybrid_search("Q1 2026 revenue forecast")
for result in results:
    print(f"Document: {result['title']}")
    print(f"Confidence: {result['confidence']}")
    print(f"Source: {result['source']}\n")

Entities (Nodes):
  - Company: "Acme Corp"
  - Department: "Engineering", "Sales", "Finance"
  - Product: "Product A", "Product B"
  - Person: "Sarah Chen", "Mike Johnson"

Relationships (Edges):
  - "Acme Corp" --manages--> "Engineering"
  - "Engineering" --builds--> "Product A"
  - "Mike Johnson" --leads--> "Engineering"
  - "Sarah Chen" --oversees--> "Product A"

MATCH (company:Company {name: "Acme Corp"})-[: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:
        # Extract text
        text_content = doc.page_content

        # Extract images and tables
        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

# Multimodal analysis with GPT-4V
def analyze_with_vision(multimodal_content):
    client = ChatOpenAI(model="gpt-4-vision-preview")

    messages = [
        SystemMessage(content="You are an expert corporate document analyst. Analyze the provided text, images, and tables comprehensively."),
        HumanMessage(
            content=[
                {
                    "type": "text",
                    "text": "What are the most important financial metrics in this document?"
                },
                *[{"type": item['type'], "data": item['content']}
                  for item in multimodal_content[:3]]
            ]
        )
    ]

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

┌─────────────────────────────────────────────────┐
│          User Interface Layer                    │
│  (Web, Mobile, Voice, Slack, Teams)             │
└──────────────┬──────────────────────────────────┘
               │
┌──────────────▼──────────────────────────────────┐
│      Orchestration / Agent Layer                 │
│  (LangChain / LlamaIndex Agents)                │
└──────────────┬──────────────────────────────────┘
               │
      ┌────────┼────────┐
      │        │        │
┌─────▼──┐ ┌──▼────┐ ┌─▼──────┐
│LLM    │ │Search │ │Tools   │
│Engine │ │Engine │ │Plugin  │
└────────┘ └───────┘ └────────┘
      │        │        │
      └────────┼────────┘
               │
      ┌────────▼────────────────┐
      │    Data Layer            │
      │                         │
      │ ┌─────────────────────┐ │
      │ │Vector DB (Pinecone) │ │
      │ │Keyword (Elasticsearch)│
      │ │Graph DB (Neo4j)     │ │
      │ │Metadata Store (SQL) │ │
      │ └─────────────────────┘ │
      │                         │
      │ ┌─────────────────────┐ │
      │ │Document Sources     │ │
      │ │ - Internal wikis    │ │
      │ │ - Email archives    │ │
      │ │ - Reports library   │ │
      │ │ - Real-time data    │ │
      │ └─────────────────────┘ │
      └──────────────────────────┘

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

# Configure Weaviate client
client = weaviate.Client("http://localhost:8080")

# Setup vector store
vector_store = WeaviateVectorStore(client=client)
storage_context = StorageContext.from_defaults(vector_store=vector_store)
embed_model = OpenAIEmbedding()

# Load and index documents
documents = [
    Document(
        text="Q1 revenue: $50M, Q2: $52M, Q3: $48M, Q4: $55M projected for 2026.",
        metadata={"source": "Financial_Plan_2026", "department": "Finance", "date": "2026-03-16"}
    ),
    Document(
        text="New product launch scheduled for April 15 with $10M marketing budget allocated.",
        metadata={"source": "Product_Roadmap", "department": "Marketing", "date": "2026-03-01"}
    )
]

# Create index with metadata filtering
index = VectorStoreIndex.from_documents(
    documents,
    storage_context=storage_context,
    embed_model=embed_model
)

# Create query engine
query_engine = index.as_query_engine(
    filters={
        "where": {
            "path": ["metadata.department"],
            "operator": "Equal",
            "valueString": "Finance"
        }
    }
)

response = query_engine.query("What are the quarterly revenue projections?")
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

# Initialize Pinecone
pinecone.init(api_key="YOUR_API_KEY", environment="YOUR_ENV")
index = pinecone.Index("knowledge-base")

# Setup vector store
embeddings = OpenAIEmbeddings()
vectorstore = Pinecone(index, embeddings.embed_query, "text")

# Define search tool
def search_knowledge_base(query):
    results = vectorstore.similarity_search(query, k=5)
    return "\n".join([doc.page_content for doc in results])

# Define business rules tool
def check_business_rules(query):
    rules = {
        "discount_limit": "Maximum 20% discount allowed",
        "contract_minimum": "Minimum contract value is $100K",
        "approval_threshold": "Above $5M requires CFO approval"
    }
    for rule, value in rules.items():
        if rule.lower() in query.lower():
            return value
    return "No matching business rule found."

# Register tools
tools = [
    Tool(
        name="Knowledge Base Search",
        func=search_knowledge_base,
        description="Search the organization's knowledge base for relevant information."
    ),
    Tool(
        name="Business Rules",
        func=check_business_rules,
        description="Look up business policies and rules."
    )
]

# Initialize agent
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
)

# Run agent
response = agent.run(
    "Can we offer a 15% discount to this customer? "
    "What are our company's discount policies?"
)
print(response)

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

# Evaluation dataset
eval_dataset = {
    "question": [
        "What are Q1-Q4 2026 revenue projections?",
        "When is the new product launch?",
        "What is the marketing budget?"
    ],
    "ground_truth": [
        "$50M, $52M, $48M, $55M",
        "April 15, 2026",
        "$10 million"
    ],
    "answer": [
        # RAG system answers
    ],
    "contexts": [
        # Retrieved contexts
    ]
}

# RAGAS evaluation
results = evaluate(
    eval_dataset,
    metrics=[
        context_precision,      # Relevance of retrieved documents
        context_recall,         # Whether needed information is included
        faithfulness,          # Answer adherence to context
        answer_relevancy       # Answer relevance to question
    ]
)

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"""
    Rewrite this question in 3 different ways:
    Original: {original_query}

    Alternative phrasings:
    """
    # Use LLM for query expansion
    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.