LlamaIndex Integration

pip install llama_index
pip install moorcheh_sdk

import logging
import sys
import os
from moorcheh_sdk import MoorchehClient
from IPython.display import Markdown, display
from typing import Any, Callable, Dict, List, Optional, cast
from llama_index.core import (
    VectorStoreIndex,
    SimpleDirectoryReader,
    StorageContext,
    Settings,
)
from llama_index.core.base.embeddings.base_sparse import BaseSparseEmbedding
from llama_index.core.bridge.pydantic import PrivateAttr
from llama_index.core.schema import BaseNode, MetadataMode, TextNode
from llama_index.core.vector_stores.types import (
    BasePydanticVectorStore,
    MetadataFilters,
    VectorStoreQuery,
    VectorStoreQueryMode,
    VectorStoreQueryResult,
)
from llama_index.core.vector_stores.utils import (
    DEFAULT_TEXT_KEY,
    legacy_metadata_dict_to_node,
    metadata_dict_to_node,
    node_to_metadata_dict,
)
from llama_index.core.vector_stores.types import (
    MetadataFilter,
    MetadataFilters,
    FilterOperator,
    FilterCondition,
)

# Logging Setup
logging.basicConfig(stream=sys.stdout, level=logging.INFO)
logging.getLogger().addHandler(logging.StreamHandler(stream=sys.stdout))

# Set the values of the API Keys in your Environment Variables
from google.colab import userdata

api_key = os.environ["MOORCHEH_API_KEY"] = userdata.get("MOORCHEH_API_KEY")

if "MOORCHEH_API_KEY" not in os.environ:
    raise EnvironmentError(f"Environment variable MOORCHEH_API_KEY is not set")

# Load Documents
documents = SimpleDirectoryReader("./documents").load_data()

# Set chunk size and overlap
Settings.chunk_size = 1024
Settings.chunk_overlap = 20

# Initialize the Moorcheh Vector Store
vector_store = MoorchehVectorStore(
    api_key=api_key,
    namespace="llamaindex_moorcheh",
    namespace_type="text",
    vector_dimension=None,
    add_sparse_vector=False,
    batch_size=100,
)

# Create a Vector Store Index using the Vector Store and given Documents
storage_context = StorageContext.from_defaults(vector_store=vector_store)
index = VectorStoreIndex.from_documents(
    documents, storage_context=storage_context
)

# Generate Response
query_engine = index.as_query_engine()
response = vector_store.generate_answer(
    query="Which company has had the highest revenue in 2025 and why?"
)

display(Markdown(f"<b>{response}</b>"))
print(f"\n\n================================\n\n{response}\n\n================================\n\n")

# Get generative answer using AI model
moorcheh_response = vector_store.get_generative_answer(
    query="Which company has had the highest revenue in 2025 and why?",
    ai_model="anthropic.claude-sonnet-4-20250514-v1:0",
)

print(f"\n\n================================\n\n{moorcheh_response}\n\n================================\n\n")

# Filters for Metadata
filter = MetadataFilters(
    filters=[
        MetadataFilter(
            key="file_path",
            value="insert the file path to the document here",
            operator=FilterOperator.EQ,
        )
    ],
    condition=FilterCondition.AND,
)

# Multiple metadata filters
filters = MetadataFilters(
    filters=[
        MetadataFilter(
            key="file_type",
            value="pdf",
            operator=FilterOperator.EQ,
        ),
        MetadataFilter(
            key="date",
            value="2024-01-01",
            operator=FilterOperator.GTE,
        )
    ],
    condition=FilterCondition.AND,
)

# Custom chunking settings
Settings.chunk_size = 512  # Smaller chunks for more precise retrieval
Settings.chunk_overlap = 50  # Higher overlap for better context preservation

vector_store = MoorchehVectorStore(
    api_key=api_key,
    namespace="llamaindex_moorcheh",
    namespace_type="text",
    batch_size=50,  # Smaller batches for memory-constrained environments
)

vector_store = MoorchehVectorStore(
    api_key=api_key,
    namespace="llamaindex_moorcheh",
    namespace_type="text",
    add_sparse_vector=True,  # Enable sparse vectors for hybrid search
)

# For general purpose queries
response = vector_store.get_generative_answer(
    query="Your question here",
    ai_model="anthropic.claude-sonnet-4-20250514-v1:0",
)

# For advanced reasoning and agentic search
response = vector_store.get_generative_answer(
    query="Complex analytical question",
    ai_model="anthropic.claude-sonnet-4-5-20250929-v1:0",
)

try:
    response = vector_store.get_generative_answer(
        query="Your question",
        ai_model="anthropic.claude-sonnet-4-20250514-v1:0",
    )
    print(response)
except Exception as e:
    print(f"Error generating answer: {e}")

# Enable debug logging
logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)
logging.getLogger().addHandler(logging.StreamHandler(stream=sys.stdout))

from llama_index.embeddings import OpenAIEmbeddings

# Use custom embeddings
embeddings = OpenAIEmbeddings()
Settings.embed_model = embeddings

class CustomMoorchehVectorStore(MoorchehVectorStore):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        # Add custom initialization logic

# Enable hybrid search with sparse vectors
vector_store = MoorchehVectorStore(
    api_key=api_key,
    namespace="hybrid_search",
    namespace_type="text",
    add_sparse_vector=True,
)

# Load financial documents
documents = SimpleDirectoryReader("./financial_reports").load_data()

# Configure for financial analysis
Settings.chunk_size = 1024
Settings.chunk_overlap = 100

# Create vector store
vector_store = MoorchehVectorStore(
    api_key=api_key,
    namespace="financial_analysis",
    namespace_type="text",
)

# Query financial data
response = vector_store.get_generative_answer(
    query="What were the key financial metrics for Q4 2024?",
    ai_model="anthropic.claude-sonnet-4-20250514-v1:0",
)

# Load legal documents
documents = SimpleDirectoryReader("./legal_docs").load_data()

# Configure for legal documents
Settings.chunk_size = 2048  # Larger chunks for legal context
Settings.chunk_overlap = 200

# Create vector store with metadata filtering
vector_store = MoorchehVectorStore(
    api_key=api_key,
    namespace="legal_documents",
    namespace_type="text",
)

# Query with metadata filters
filters = MetadataFilters(
    filters=[
        MetadataFilter(
            key="document_type",
            value="contract",
            operator=FilterOperator.EQ,
        )
    ]
)