AWS Architecture for LLM, GenAI, RAG, and Graph

 

                                                                    AWS

Here's a concise breakdown of what’s in the AWS contact center RAG architecture and modern AWS innovations/tools you can consider adding/enhancing for LLM, GenAI, RAG, and Graph-based use cases:

---

✅ Current Architecture Summary

• Core Interaction:

  • Amazon Connect + Lex: Voice/chat → Lex bot

  • AWS Lambda: Fulfillment logic → interacts with LLMs & KB

  • Amazon Bedrock: Claude & Cohere embedding

  • Amazon OpenSearch Serverless: RAG KB indexing

  • Amazon S3: Document storage

  • Amazon SageMaker: LLM testing

  • CloudWatch + Athena + QuickSight: Analytics, logs, and dashboards

---

🚀 Modern AWS Additions to Enhance This Architecture

1. Amazon Knowledge Bases for Amazon Bedrock (NEW)

• Built-in RAG: No manual embedding/indexing needed.

• Direct integration with Claude, Titan, Mistral, Llama2.

• Secure and scalable for contact center FAQs, SOPs.

→ Replace OpenSearch + manual embed with this for simplicity.

---

2. Amazon Titan Models

• Titan Text G1, Titan Embeddings G1:

  • Optimized for AWS native workloads

  • Good accuracy & cost-performance

  • Can replace Cohere embeddings in Bedrock

---

3. Amazon Neptune + Bedrock for Graph RAG

• Use Amazon Neptune (Graph DB):

  • Create context-aware responses using entities/relationships.

  • Ideal for contact center use cases like product recommendations, account histories, support dependencies.

• Use Neptune ML + Bedrock for hybrid Graph-RAG workflows.

---

4. Agent Assist with Amazon Q (for internal agents)

• Auto-suggested answers to agents.

• Integrate Amazon Q Developer Agent for internal workflow orchestration.

---

5. Vector Search with Amazon Aurora PostgreSQL + pgvector

• Use Aurora PostgreSQL with pgvector to enable hybrid RAG + transactional DB in a single place.

• Ideal if customer/CRM data is already in Aurora.

---

6. Amazon AppFabric (for SaaS integration)

• Integrate Zendesk, Salesforce, ServiceNow logs for richer LLM context (ideal in contact center scenarios).

---

7. Guardrails for Amazon Bedrock

• Native prompt filters, PII blocking, toxicity checks.

• Useful to extend security in fulfillment function layer.

---

8. Amazon DataZone + Bedrock for Enterprise Context

• Federated data access to S3, Redshift, RDS etc.

• Feed knowledge into LLMs securely via Bedrock.

---

9. Amazon PartyRock (for internal prototyping)

• Quickly test RAG flows or new ideas before deployment.

---

📌 Suggestions for Improvement

Area	Suggestion
LLM Evaluation	Add PromptBench (open-source) or Amazon SageMaker Clarify to evaluate LLM responses.
RAG Indexing	Migrate to Amazon Knowledge Bases to reduce complexity.
Graph Context	Use Amazon Neptune + LLM for better connected Q&A.
Storage Index	Use Amazon S3 Object Lambda to trigger smart preprocessing on upload.
Agent UX	Add Amazon Q for contact center agents (internal-facing copilot).
Observability	Add Amazon CloudTrail Lake for deeper insight beyond CloudWatch.

---

Here’s a focused breakdown of Amazon Bedrock in the context of this architecture, including what it does, how it fits, and what more you can do with it using the latest AWS innovations:

---

✅ Current Role of Amazon Bedrock in This Architecture

• Models Used:

  • Anthropic Claude (Haiku, Sonnet): For generating answers

  • Cohere Embed v3: For semantic embedding of documents

• Tasks:

  • Response generation

  • Embedding via Cohere

  • Guardrails and evaluation logic via Lambda

---

🚀 Modern Capabilities in Amazon Bedrock You Can Leverage

1. Amazon Knowledge Bases for Bedrock (NEW - 2024)

• Built-in RAG with no manual vector DB or embedding setup.

• Supports ingestion from S3, websites, Salesforce, etc.

• Automatically uses Titan or Claude behind the scenes.

Replace this part of your diagram:

Amazon S3 + OpenSearch + manual Cohere embedding
→ Use Amazon Knowledge Base with Bedrock instead

---

2. Amazon Bedrock Guardrails (NEW)

• Define prohibited topics, allowed responses, and safety filters.

• Supports moderation at prompt input & response output.

• Integrates with Claude, Titan, and Mistral models.

Use case: In fulfillment Lambda → Add Bedrock Guardrails for:

• Hallucination control

• PII filtering

• Bias/toxicity control

---

3. Agents for Amazon Bedrock

• Lets you create multi-step conversational agents.

• Define tools/functions (e.g., API calls, DB reads).

• Automate complex business flows using LLM.

Use case: Replace manual Lambda orchestration with Bedrock agent that can:

• Read user input

• Trigger APIs

• Retrieve from RAG

• Generate final output

---

4. Supported Foundation Models (FMs)

Use new FMs directly from Bedrock:

• Anthropic Claude 3

• Meta Llama 2/3

• Mistral

• Amazon Titan

• Cohere Command-R

Pick based on: Cost, latency, token limits, reasoning.

---

5. Streaming + Low-latency Inference

• Supports streaming responses for faster UX

• Useful in real-time contact center flows

---

🔁 Optional Enhancements with Bedrock

Enhancement	Tool	Impact
Native RAG	Bedrock + Knowledge Base	Simpler setup, high performance
Safety	Bedrock Guardrails	Reduce hallucination & risk
Conversational Flow	Bedrock Agents	No manual Lambda FSM
Graph-enhanced answers	Neptune + Bedrock	Better context for complex queries
Response speed	Bedrock Streaming	Better UX for chat-like UIs

---

If you need to integrate a graph database into this architecture on AWS (especially for context-rich LLM responses, entity linking, or decision reasoning), the go-to service is:

---

🧠 Amazon Neptune – AWS Managed Graph Database

✅ Use Cases in LLM + RAG Context

• Entity linking: Resolve ambiguous terms via graph traversal.

• Personalized answers: Use graph to tailor based on user profile/intent.

• Relationship-aware Q&A: Example: “Which agents have handled both Product A and B cases?”

• Knowledge Graph RAG: Supplement text-based RAG with structured semantic relationships.

---

📌 How to Integrate into Your Architecture

1. Document Upload / Knowledge Source Ingestion:

   • When uploading documents to S3, extract entities & relationships using:

     • Amazon Comprehend (or custom model)

     • Amazon SageMaker + spaCy or LangChain parser

   • Push triples into Neptune.

2. Link Neptune with Bedrock (via Lambda):

   • At runtime, fetch related facts from Neptune

   • Inject into prompt via LangChain Tool / Function Call

   • Claude/Titan gets graph context + retrieved docs = better answers

3. Store Conversation Graph:

   • Create user-session graphs showing what was asked, which intents resolved

   • Analyze later in QuickSight or SageMaker

---

🛠 Tools to Use

• Amazon Neptune ML: To do graph embeddings & reasoning (built-in SageMaker)

• LangChain: Built-in Neptune integration

• Neptune Streams: Real-time updates to apps when graph changes

• IAM + VPC: Ensure private access from Lambda/Bedrock to Neptune

---

🧩 Sample Add-On Workflow

Customer question → Amazon Lex → Lambda (calls Neptune for entity resolution)
→ Lambda queries RAG (via Bedrock) + enriches with graph facts
→ LLM response includes accurate, structured insight

---

Here’s how you can enhance the existing contact center RAG solution architecture with new AWS innovations (as of 2024–2025):

---

🔹 1. Amazon Bedrock Enhancements

• New Foundation Models (FMs) now available:

  • Cohere Command R+ / Embed v3: Great for multilingual semantic search and summarization.

  • Stability AI: Enable image generation (e.g., visual summaries or diagrams in contact center dashboards).

  • Claude 3 / Sonnet / Haiku: Improved reasoning, lower hallucination, better for safety-critical workflows.

✅ What to add:

• Use Claude 3 Sonnet for improved hallucination detection and conversational quality.

• Add Cohere Embed v3 to handle multilingual RAG and user queries.

• Optionally add Stability AI for visual response generation (e.g., charts/diagrams in product support).

---

🔹 2. Amazon Q Integration

• Amazon Q: GenAI assistant now integrated with Amazon Connect and other AWS services.

  • Use Q for Agents: Automatically summarize calls, suggest actions, and provide live answers.

  • Use Q for Developers: Help internal teams debug and deploy improvements in Lambda, Lex, and Bedrock workflows.

✅ What to add:

• Integrate Amazon Q Agent Assist in Amazon Connect flow for real-time suggestions and summarization.

• Embed Q analytics to enhance QuickSight dashboards with natural language insights.

---

🔹 3. Graph Reasoning with Amazon Neptune

• Add Amazon Neptune for:

  • Knowledge Graph + RAG Hybrid.

  • Entity resolution, reasoning, semantic memory, user-persona linking.

• Combine Neptune ML + Bedrock via Lambda or LangChain.

✅ What to add:

• Store structured knowledge as RDF/triples.

• During RAG, fetch graph facts and add to prompt before LLM call.

---

🔹 4. New LangChain + AWS Integrations

• Use LangChain AWS Toolkit for:

  • Neptune integration for structured reasoning.

  • Bedrock tool calling, agents, and multi-hop chains.

✅ What to add:

• Use LangGraph + Bedrock to orchestrate complex dialogues across Lex, Bedrock, Neptune, and OpenSearch.

---

🔹 5. Vector Store Upgrade

• Consider replacing OpenSearch with Amazon Aurora PostgreSQL + pgvector for:

  • Faster semantic search.

  • Tighter integration with RDS ecosystem.

Optional Enhancement.

---

🧠 Final Enhanced Stack (Key Adds)

• Amazon Bedrock:

  • Claude 3 Sonnet, Cohere Embed v3, Stability AI

• Amazon Q:

  • Agent Assist in Amazon Connect

• Amazon Neptune:

  • Graph-based reasoning, persona modeling

• LangChain + LangGraph:

  • Complex workflows, agent memory

• Optionally:

  • Use Aurora + pgvector for hybrid RAG

---

Check my several template codes to start or customise your solution here.

Azure platform for machine learning and generative AI RAG

Connecting on-premises data to the Azure platform for machine learning and generative AI Retrieval Augmented Generation (RAG) involves several steps. Here’s a step-by-step guide:

Step 1: Set Up Azure Machine Learning Workspace

1. Create an Azure Machine Learning Workspace: This is your central place for managing all your machine learning resources.

2. Configure Managed Virtual Network: Ensure your workspace is set up with a managed virtual network for secure access to on-premises resources.

Step 2: Establish Secure Connection

1. Install Azure Data Gateway: Set up an Azure Data Gateway on your on-premises network to securely connect to Azure.

2. Configure Application Gateway: Use Azure Application Gateway to route and secure communication between your on-premises data and Azure workspace.

Step 3: Connect On-Premises Data Sources

1. Create Data Connections: Use Azure Machine Learning to create connections to your on-premises data sources, such as SQL Server or Snowflake - Azure Machine ...](https://learn.microsoft.com/en-us/azure/machine-learning/how-to-connection?view=azureml-api-2).

2. Store Credentials Securely: Store credentials in Azure Key Vault to ensure secure access - Azure Machine ...](https://learn.microsoft.com/en-us/azure/machine-learning/how-to-connection?view=azureml-api-2).

Step 4: Data Integration and Processing

1. Data Ingestion: Use Azure Databricks or Azure Machine Learning Studio to ingest data from your on-premises sources on Azure Databricks](https://learn.microsoft.com/en-us/azure/databricks/generative-ai/retrieval-augmented-generation).

2. Data Processing: Clean, transform, and preprocess your data using Azure Databricks or Azure Machine Learning tools.

Step 5: Build and Train Models

1. Model Development: Develop your machine learning models using Azure Machine Learning Studio or Azure Databricks on Azure Databricks](https://learn.microsoft.com/en-us/azure/databricks/generative-ai/retrieval-augmented-generation).

2. Model Training: Train your models on the processed data on Azure Databricks](https://learn.microsoft.com/en-us/azure/databricks/generative-ai/retrieval-augmented-generation).

Step 6: Deploy and Monitor Models

1. Model Deployment: Deploy your trained models to Azure Machine Learning for real-time predictions.

2. Monitoring and Management: Use Azure Monitor and Azure Machine Learning to monitor model performance and manage deployments.

Step 7: Implement RAG

1. Integrate with Azure AI Search: Use Azure AI Search for indexing and retrieving relevant data for your RAG system.

2. Use Azure OpenAI Service: Integrate with Azure OpenAI Service for generative AI capabilities.

3. Customize RAG Workflow: Design a custom RAG workflow using Azure AI Search, Azure OpenAI, and other Azure tools to enhance your generative AI applications.

Azure Data Lake Storage Gen2 (ADLS Gen2) is an excellent choice for storing unstructured data. It combines the capabilities of Azure Blob Storage and Azure Data Lake Storage, making it suitable for big data analytics. Here’s how you can make the most of it:

Key Features

- Scalability: It can handle large volumes of unstructured data, scaling as needed.

- Integration: Seamlessly integrates with Azure services like Azure Machine Learning, Databricks, and Synapse Analytics.

- Security: Provides robust security features, including encryption and access control, to protect your data.

- Cost-Effectiveness: Offers tiered storage options to optimize costs based on data access patterns.

How to Use ADLS Gen2 for Unstructured Data

1. Set Up Storage Account: Create an Azure Storage account with hierarchical namespace enabled.

2. Create Containers: Organize your data by creating containers within the storage account.

3. Upload Data: Use tools like Azure Storage Explorer or Azure CLI to upload your unstructured data (e.g., logs, images, videos).

4. Access Data: Access your data using various Azure services and tools for processing and analytics.

5. Manage and Monitor: Use Azure Monitor and Azure Security Center to manage and monitor your data lake.

Integration with AI/ML Tools

1. Azure Machine Learning: Store training data and results in ADLS Gen2, and use it directly from Azure Machine Learning for model training and experimentation.

2. Azure Databricks: Leverage Databricks to process and analyze unstructured data stored in ADLS Gen2 using Spark.

3. Azure Synapse Analytics: Use Synapse to query and analyze large datasets stored in ADLS Gen2, combining it with structured data sources.

Using ADLS Gen2 ensures you have a scalable, secure, and integrated solution for managing unstructured data, making it an ideal choice for your AI and ML projects. 

Data Ingestion for Retrieval-Augmented Generation (RAG)

Data Ingestion for Retrieval-Augmented Generation (RAG)

Data Ingestion is a critical initial step in building a robust Retrieval-Augmented Generation (RAG) system. It involves the process of collecting, cleaning, structuring, and storing diverse data sources into a format suitable for efficient retrieval and generation.

Key Considerations for Data Ingestion in RAG:

1. Data Source Identification:

   • Internal Data:
     • Company documents, reports, knowledge bases, customer support tickets, etc.
     • Proprietary databases, spreadsheets, and other structured data.
   • External Data:
     • Publicly available datasets (e.g., Wikipedia, Arxiv)
     • News articles, blog posts, research papers from various sources
     • Social media data (with appropriate ethical considerations)

2. Data Extraction and Cleaning:

   • Text Extraction: Extracting relevant text from various formats (PDF, DOCX, HTML, etc.)
   • Data Cleaning: Removing noise, inconsistencies, and irrelevant information
   • Normalization: Standardizing text (e.g., lowercase, punctuation removal)
   • Tokenization: Breaking text into smaller units (tokens) for indexing and retrieval

3. Data Structuring and Storage:

   • Document Indexing: Creating a searchable index of documents
   • Vector Database: Storing documents as numerical representations (embeddings) for efficient similarity search
   • Knowledge Graph: Representing relationships between entities and concepts in a structured format

4. Data Enrichment:

   • Metadata Extraction: Extracting relevant metadata (e.g., author, date, source)
   • Semantic Annotation: Adding semantic tags to documents for better understanding and retrieval
   • Summarization: Creating concise summaries of long documents

Challenges and Best Practices:

• Data Quality and Consistency: Ensuring data accuracy, completeness, and consistency across sources
• Scalability: Handling large volumes of data and efficient indexing
• Privacy and Security: Protecting sensitive information and complying with regulations
• Data Freshness: Keeping the knowledge base up-to-date with the latest information
• Continuous Learning: Adapting to evolving data sources and user needs

By effectively addressing these challenges, organizations can build powerful RAG systems that can generate accurate, relevant, and informative responses to user queries.

The first step of data ingestion is:

Collection: Gathering data from various sources, such as databases, files, APIs or external platforms.

Data ingestion is the process of collecting, processing and storing data to make it available for analysis or other uses. The typical steps involved in data ingestion are:

Collection: Gathering data from various sources.

Formatting: Cleaning, transforming and organizing the collected data into a standardized format.

Storing: Loading the formatted data into a storage system, such as a database or data warehouse.

Processing/Chunking: Breaking down large datasets into smaller, manageable pieces (chunking) and preparing them for analysis.

Generate embedding is not typically considered a step in data ingestion but is rather related to data representation or machine learning applications where embeddings are used to represent complex data (like text or images) in a numerical format that algorithms can process more easily.

HNSW enables fast and scalable indexing, retrieval and similarity searches of vector embeddings. It works by creating a hierarchical graph structure that facilitates navigation and search through the vectors, allowing for:

Efficient similarity searches

Fast query performance

Scalability to large datasets

HNSW is particularly useful in applications requiring approximate nearest neighbor searches, such as:

Image and video search

Natural Language Processing (NLP)

Recommendation systems

Clustering and classification tasks

Chunk overlapping involves creating chunks that partially overlap each other. This ensures contextual continuity and maintains relationships between adjacent text segments.

Benefits of chunk overlapping:

Preserves context: Important contextual information is retained across chunk boundaries.

Improves accuracy: Enhances the accuracy of downstream NLP tasks, such as named entity recognition, sentiment analysis and question answering.

Reduces edge effects: Mitigates the impact of chunk boundaries on model performance.

Other options:

Chunk by paragraph: May not preserve context if paragraphs are long or contain multiple ideas.

Decrease chunk size: Smaller chunks may lose contextual relationships.

Increase chunk size: Larger chunks can lead to computational inefficiencies and decreased model performance.

Best practices:

Choose optimal chunk overlap sizes based on specific NLP tasks and data characteristics.

Balance overlap with computational efficiency.

Experiment with different chunking strategies for optimal results.

To improve the performance of your vector search query, consider:

Optimizations

Increase the numCandidates: Returns more candidate vectors, enhancing recall and accuracy but potentially impacting performance.

Use the filter field: Applies filters to narrow down search results, reducing computational load and improving efficiency.

Additional Strategies

Optimize vector indexing: Utilize efficient indexing algorithms like Hierarchical Navigable Small World (HNSW) or Annoy.

Quantization: Reduce precision of vector dimensions (e.g., float16) for faster computation and storage.

Vector pruning: Remove irrelevant or redundant vectors.

Query optimization: Optimize query formulation, considering factors like query vector quality and similarity metrics.

When Not to Use

Increase vector dimensions: More dimensions increase computational complexity and storage needs without guaranteeing better results.

Exact nearest neighbor search: Computationally expensive; approximations (e.g., HNSW, Annoy) are often sufficient.

Best Practices

Monitor performance metrics.

Experiment with parameters.

Balance accuracy and efficiency.

Consider hardware upgrades or distributed computing for large-scale applications.

Must use the same model for the $vectorSearch query as was used during data indexing

To ensure accurate results, the same embedding model used for indexing vector embeddings must be used in the $vectorSearch query.

Key considerations:

Model consistency: Ensure indexing and querying use the same model.

Vector compatibility: Vectors from the same model are compatible.

Accurate results: Consistent models guarantee accurate similarity measurements.

Role of Atlas in RAG Components

1. Retriever

Utilizes Atlas's Vector Search capabilities for efficient similarity searches.

Queries the vector index to retrieve relevant documents.

2. Vector Store

Stores vector embeddings of documents in Atlas.

Enables fast retrieval and similarity searches.

Other Components

Answer Generator: Generates answers based on retrieved documents, typically using a language model.

Text Splitter: Splits input text into manageable chunks for processing.

Prompt: Defines the input query or task for the RAG system.

Benefits of Using Atlas

Scalable vector search

Efficient document retrieval

Improved performance for large datasets

By filtering data before performing a search on vectors

Leveraging metadata improves RAG system performance by:

Pre-Filtering Benefits

Reduced search space: Filters out irrelevant documents before vector search.

Faster query execution: Decreases computational load.

Improved accuracy: Focuses search on relevant data.

Common Metadata Filters

Date ranges: Limit search to specific time periods.

Content types: Restrict to relevant document types (e.g., articles, research papers).

Authorship: Filter by author or organization.

Categories: Limit search to predefined categories.

Additional Optimization Strategies

Efficient vector indexing: Utilize algorithms like HNSW or Annoy.

Optimized chunking: Balance context and computational efficiency.

Model selection: Choose suitable embedding models.

Benefits

Enhanced performance

Improved accuracy

Reduced computational costs

Scalability for large datasets

Vector embeddings group similar data points into clusters, representing semantic relationships.

Vector Embedding Properties

Proximity: Similar vectors (embeddings) are closer together.

Distance: Dissimilar vectors are farther apart.

Dimensionality: Vectors capture complex relationships in multidimensional space.

Cluster Interpretation

Semantic meaning: Clusters represent concepts, entities or themes.

Pattern recognition: Groupings reveal underlying patterns.

Relationships: Clusters show associations between data points.

Applications

Information retrieval: Efficient similarity searches.

Clustering: Unsupervised learning.

Classification: Supervised learning.

Recommendation systems: Content suggestions.

Vector embeddings are widely used in:

Natural Language Processing (NLP)

Computer Vision

Recommendation systems

To identify the most relevant result by scoring the results from vector search and text search

Reciprocal Rank Fusion (RRF) combines rankings from vector search and text search to:

Improve overall search relevance.

Fuse rankings into a single, more accurate result set.

Leverage strengths of both search methods.

How RRF Works

Normalizes rankings from vector and text searches.

Calculates reciprocal ranks for each document.

Combines reciprocal ranks for final scoring.

Benefits

Enhanced search accuracy.

Robust handling of diverse query types.

Improved relevance ranking.

RRF effectively merges vector search's semantic understanding with text search's keyword precision.

To return contextually relevant chunks

The Retriever's main purpose in a Retrieval-Augmented Generator (RAG) system:

Fetches relevant document chunks from database or index.

Uses vector search, keyword search or hybrid methods.

Returns top-ranked chunks matching query context.

Key Functions

Query understanding

Document ranking

Chunk extraction

Relevance filtering

Benefits

Efficient information retrieval

Improved contextual understanding

Enhanced answer accuracy

Reduced latency for large datasets

The Retriever feeds relevant chunks to the Generator (LLM) for response assembly.

Approximate Nearest Neighbor (ANN)

For large collections (>300,000 documents), Approximate Nearest Neighbor (ANN) search algorithms provide optimal performance in Atlas Vector Search.

Why ANN?

Scalability: Handles massive datasets efficiently.

Speed: Faster query execution compared to exact methods.

Accuracy: Near-exact results with minimal compromise.

Popular ANN Algorithms

Hierarchical Navigable Small World (HNSW)

Annoy (Approximate Nearest Neighbors Oh Yeah!)

FAISS (Facebook AI Similarity Search)

Benefits

Fast query execution (ms-range)

Low latency

Efficient indexing

Suitable for high-dimensional vector spaces

Comparison

Algorithm Performance Accuracy Scalability

Exact Nearest Slow High Low

K-Nearest Medium Medium Medium

Approximate NN Fast Near-exact High

Linear Search Very Slow Exact Very Low

The embedding model used

Vector embedding dimensionality is primarily determined by the chosen embedding model's architecture and configuration.

Factors Influencing Dimensionality

Model architecture: Word2Vec, BERT, Transformers, etc.

Model size: Small, base or large variants.

Configuration: Hyperparameters (e.g., embedding size).

Training objectives: Task-specific optimizations.

Common Embedding Dimensions

Word2Vec: 100-500 dimensions

BERT: 768 (base), 1024 (large)

Sentence-BERT (Sentence Embeddings): 384-768

Considerations

Balance between complexity and generalizability

Computational resources and scalability

Task-specific requirements

Other options are secondary or unrelated:

Desired output format: Affects representation, not dimensionality.

Storage capacity: Influences indexing and storage efficiency.

Source data size: Impacts training time and model complexity.

A process that involves combining full-text and semantic search capabilities

Hybrid Search integrates:

Full-text search: Keyword matching, exact queries.

Semantic search: Vector embeddings, contextual understanding.

Benefits

Improved accuracy: Combines precision and recall.

Enhanced relevance: Understands context and intent.

Flexibility: Handles diverse query types.

Hybrid Search Techniques

Vector-Text Fusion: Combines vector and text search rankings.

Reciprocal Rank Fusion: Scores and merges results.

Two-Stage Search: Initial text search, followed by vector refinement.

Applications

Information retrieval

Question answering

Document search

Conversational AI

Hybrid Search is particularly useful in Retrieval-Augmented Generator (RAG) systems, enhancing overall search performance.

Atlas Vector Search utilizes dense vectors for efficient similarity searches.

Characteristics of Dense Vectors

Fixed-length: Vectors have equal dimensions.

Floating-point numbers: Precise representation.

Non-zero values: Captures nuanced relationships.

Advantages

Semantic understanding: Encodes contextual meaning.

Efficient indexing: Enables fast similarity searches.

Scalability: Supports large datasets.

Why Not Sparse Vectors?

Sparse vectors are inefficient for Atlas Vector Search due to:

High dimensionality: Increases storage and computation.

Zero-valued dominance: Reduces search accuracy.

Dense Vector Applications

Semantic search: Captures contextual intent.

Recommendation systems: Identifies nuanced preferences.

Information retrieval: Enhances relevance ranking.

Dense vectors are generated using techniques like:

Word2Vec

BERT

Sentence-BERT

Transformers