RAG Patent Analysis System

A comprehensive Retrieval-Augmented Generation (RAG) system for intelligent patent analysis using multi-agent AI, semantic search, and privacy-preserving local LLMs. This system combines CrewAI agents with OpenSearch and Ollama to provide powerful patent trend analysis, forecasting, and discovery capabilities.

🎯 Project Overview

This project implements an intelligent patent analysis and search system that combines cutting-edge technologies:

Semantic Search: Advanced vector-based patent retrieval using embeddings for meaning-based search
CrewAI Multi-Agent System: Specialized AI agents working together for comprehensive patent trend analysis and forecasting
Hybrid Search: Combines keyword and semantic search for optimal retrieval accuracy
OpenSearch Backend: Distributed vector and full-text search engine with dashboard visualization
Local LLM Privacy: Uses Ollama for on-premise, privacy-preserving language model inference
Lithium Battery Focus: Specialized analysis for lithium battery technology patents

Key Features

🔍 Multiple Search Strategies: Semantic, keyword, hybrid, and iterative search methods
🤖 AI-Powered Analysis: CrewAI agents for automated patent analysis and trend forecasting
📊 Citation Analysis: Extract and analyze patent citations for technology evolution tracking
🎨 Interactive Dashboard: OpenSearch Dashboards for visualization and monitoring
🔐 Privacy-First: All processing done locally without external API calls for data
📈 Scalable Architecture: Designed to handle large patent datasets efficiently

📁 Project Structure

RAG/
├── Core Application Files
│   ├── agentic_rag.py            # Main CLI interface with interactive menu system
│   ├── patent_crew.py            # CrewAI agent definitions and orchestration
│   └── patent_search_tools.py    # Search implementations (semantic, keyword, hybrid, iterative)
│
├── Data Processing & Integration
│   ├── ingestion.py              # Patent data loading, chunking, and indexing pipeline
│   ├── embedding.py              # Vector embedding generation using Ollama
│   ├── opensearch_client.py      # OpenSearch client, connection, and index management
│   ├── information_collector.py  # Web data collection and processing utilities
│   └── helper.py                 # General utility and helper functions
│
├── Configuration & Deployment
│   ├── docker-compose.yml        # Docker Compose configuration for OpenSearch services
│   ├── .env                      # Environment variables (API keys, model configs)
│   └── requirements.txt          # Python dependencies
│
├── Development & Analysis
│   ├── dev.ipynb                 # Jupyter notebook for experimentation and development
│   └── patent_analysis_*.txt     # Generated analysis reports with timestamps
│
├── Data Storage
│   ├── files/
│   │   ├── patents.json          # Primary patent dataset with metadata
│   │   └── patent_details.json   # Extended patent information (claims, descriptions)
│   │
│   └── results/                  # Analysis outputs and extracted data
│       ├── patent_data_*.json    # Indexed patent data by batch
│       ├── citation_*.json       # Extracted citation networks
│       └── [Analysis reports]
│
└── Documentation
    ├── README.md                 # This file
    └── [Additional documentation]

📊 Data Files

patents.json: Main patent dataset containing core metadata, abstracts, and search parameters
patent_details.json: Extended patent information including detailed descriptions, claims, and technical classifications
results/: Output directory containing:
- patent_data_*.json: Chunked and processed patent records ready for indexing
- citation_*.json: Extracted patent citation relationships and networks
- Analysis reports with timestamps for trend analysis and forecasting results

🚀 Setup & Installation

Prerequisites

Python 3.10+: Core language for the application
Docker & Docker Compose: For running OpenSearch and dashboards
Ollama: Local LLM inference engine with models pre-installed
- Download from: https://ollama.ai
- Recommended models: llama2, nomic-embed-text
Git: For repository management
pip/pip-tools: Python package management

Installation Steps

Step 1: Clone and Setup Environment

# Clone the repository
git clone <repository-url>
cd RAG

# Create virtual environment
python -m venv venv

# Activate virtual environment
# On Windows:
venv\Scripts\activate
# On macOS/Linux:
source venv/bin/activate

Step 2: Install Python Dependencies

# Install required packages
pip install -r requirements.txt

# Optional: Install Jupyter for development notebook
pip install jupyter jupyterlab

Step 3: Setup Environment Variables

Create a .env file in the project root:

SERP_API_KEY=your_serp_api_key_here
OLLAMA_HOST=http://localhost:11434
OPENSEARCH_HOST=localhost
OPENSEARCH_PORT=9200
OPENSEARCH_USER=admin
OPENSEARCH_PASSWORD=admin

Step 4: Start Infrastructure Services

# Start OpenSearch and OpenSearch Dashboards using Docker Compose
docker-compose up -d

# Verify services are running
docker-compose ps

Service Endpoints:

OpenSearch: http://localhost:9200
OpenSearch Dashboards: http://localhost:5601
Default credentials: admin / admin

Step 5: Setup Ollama Models

In a new terminal, start Ollama and pull required models:

# Start Ollama service
ollama serve

# In another terminal, pull models
ollama pull llama2
ollama pull nomic-embed-text

# Verify models are available
curl http://localhost:11434/api/tags

Step 6: Ingest Patent Data

# Load patents into OpenSearch and generate embeddings
python ingestion.py

What this does:

Loads patent data from files/patents.json and files/patent_details.json
Generates vector embeddings using Ollama's embedding model
Creates/updates OpenSearch indexes with proper vector mappings
Stores metadata alongside embeddings for retrieval
Generates processed data files in results/ directory

Expected output:

Connected to OpenSearch!
Loading patent data...
Processing 5000 patents...
Creating index 'patents' with vector mappings...
Indexing complete: 5000 documents indexed

💻 Usage Guide

Interactive Patent Analysis CLI

The main entry point is agentic_rag.py, which provides an interactive menu-driven interface:

python agentic_rag.py

Main Menu Options:

1. Run complete patent trend analysis and forecasting
   - Analyzes patent trends in the specified research area
   - Generates insights using CrewAI agents
   - Produces forecasting reports
   - Outputs results to patent_analysis_[timestamp].txt

2. Search for specific patents
   - Query by keywords or concepts
   - Returns top matching patents
   - Shows title, abstract, publication date, and patent ID
   - Displays relevance scores

3. Iterative patent exploration
   - Step-by-step patent discovery
   - Refine searches based on results
   - Explore related patents and citations
   - Build comprehensive understanding of topic

4. View system status
   - Check OpenSearch connectivity
   - Verify Ollama availability and models
   - Display system information
   - Diagnose connectivity issues

5. Exit
   - Gracefully shutdown application

Search Operations

The patent_search_tools.py module provides four search strategies:

1. Semantic Search

from patent_search_tools import semantic_search

results = semantic_search(
    query_text="solid-state battery technology advancements",
    top_k=10
)
# Returns: Semantically similar patents based on meaning

Uses vector embeddings for meaning-based retrieval
Best for: Conceptual searches, technology trend analysis
Performance: Slower but more accurate for complex queries

2. Keyword Search

from patent_search_tools import keyword_search

results = keyword_search(
    query_text="lithium ion battery cathode",
    top_k=10
)
# Returns: Patents matching keywords in title/abstract

Traditional inverted-index based search
Best for: Specific terms, known technologies
Performance: Fast, real-time results

3. Hybrid Search

from patent_search_tools import hybrid_search

results = hybrid_search(
    query_text="battery thermal management",
    top_k=10
)
# Returns: Combination of semantic and keyword results

Merges results from both search methods
Best for: Balanced retrieval, general exploration
Performance: Combines benefits of both methods

4. Iterative Search

from patent_search_tools import iterative_search

results = iterative_search(
    query_text="electrode material innovation",
    top_k=10,
    iterations=3
)
# Returns: Refined results through multiple iterations

Progressively refines search results
Best for: Deep topic exploration, citation networks
Performance: Slowest but most comprehensive

Development Notebook

For experimentation and interactive analysis:

jupyter notebook dev.ipynb

The notebook provides:

Pre-configured search examples
Data exploration utilities
Custom analysis scripts
Visualization helpers

Advanced Usage: CrewAI Agent System

Access the underlying agent system directly:

from patent_crew import run_patent_analysis

result = run_patent_analysis(
    research_area="Solid-State Batteries",
    model_name="llama2"
)
print(result)

CrewAI Agents Involved:

Research Analyst: Gathers patent information
Trend Analyst: Identifies emerging technologies
Forecaster: Predicts future patent directions
Report Writer: Synthesizes findings into reports

🏗️ System Architecture

Component Overview

┌─────────────────────────────────────────────────────────────┐
│                    User Interface Layer                      │
│                    (agentic_rag.py CLI)                      │
└─────────────────────────────────────────────────────────────┘
                             ↓
┌─────────────────────────────────────────────────────────────┐
│                  Application Logic Layer                     │
├─────────────────────────────────────────────────────────────┤
│  • Patent Crew (Agents)    • Search Tools     • Helpers      │
│  • Data Processing         • Information Collection          │
└─────────────────────────────────────────────────────────────┘
                             ↓
┌─────────────────────────────────────────────────────────────┐
│                 Integration & Embedding Layer               │
├─────────────────────────────────────────────────────────────┤
│  • OpenSearch Client       • Embedding Generation            │
│  • Index Management        • Vector Operations               │
└─────────────────────────────────────────────────────────────┘
                             ↓
┌─────────────────────────────────────────────────────────────┐
│                  External Services Layer                     │
├─────────────────────────────────────────────────────────────┤
│  • OpenSearch (Port 9200)         • Ollama (Port 11434)      │
│  • OpenSearch Dashboards (5601)   • Docker Infrastructure    │
└─────────────────────────────────────────────────────────────┘

Core Components

1. OpenSearch Backend

Purpose: Distributed search and analytics engine
Features:
- Vector similarity search (KNN-based)
- Full-text keyword search
- JSON document storage with metadata
- Index management and mapping
Address: http://localhost:9200
Dashboard: http://localhost:5601 (OpenSearch Dashboards)

2. Ollama Local LLM

Purpose: Privacy-preserving language model inference
Features:
- Local model execution (no external API calls)
- Embedding generation
- Text generation and analysis
Address: http://localhost:11434
Models: llama2 (reasoning), nomic-embed-text (embeddings)

3. CrewAI Multi-Agent System

Purpose: Orchestrate specialized AI agents for complex tasks
Agent Types:
- Research Analyst: Queries and analyzes patent data
- Trend Analyst: Identifies technology trends
- Forecaster: Makes predictions about future developments
- Report Writer: Synthesizes findings into comprehensive reports

4. Search Pipeline

User Query
    ↓
[Query Preprocessing & Normalization]
    ↓
[Search Strategy Selection]
    ├→ Semantic Path (Vector Embedding)
    ├→ Keyword Path (Inverted Index)
    └→ Hybrid Path (Combined Ranking)
    ↓
[OpenSearch Query Execution]
    ↓
[Result Ranking & Deduplication]
    ↓
[Metadata Enrichment]
    ↓
[Results Returned to User/Agent]

Data Flow

Ingestion Pipeline

JSON Patent Files
    ↓
[Load & Parse]
    ↓
[Data Validation & Cleaning]
    ↓
[Text Chunking & Preprocessing]
    ↓
[Embedding Generation (Ollama)]
    ↓
[Index Creation/Update (OpenSearch)]
    ↓
[Results Stored in results/ directory]

Analysis Pipeline

User Request
    ↓
[Patent Search (Multiple Strategies)]
    ↓
[Results Aggregation]
    ↓
[CrewAI Agent Processing]
    ↓
[LLM-based Analysis]
    ↓
[Report Generation]
    ↓
[File Output + Console Display]

⚙️ Configuration

Environment Variables (.env file)

# SERP API Configuration (for web search capabilities)
SERP_API_KEY=your_api_key_here

# Ollama Configuration
OLLAMA_HOST=http://localhost:11434
OLLAMA_MODEL=llama2
EMBEDDING_MODEL=nomic-embed-text

# OpenSearch Configuration
OPENSEARCH_HOST=localhost
OPENSEARCH_PORT=9200
OPENSEARCH_USER=admin
OPENSEARCH_PASSWORD=admin

# Application Settings
PATENT_RESEARCH_AREA=Lithium Battery
DATA_DIR=./files
RESULTS_DIR=./results

Docker Services Configuration

OpenSearch Settings (docker-compose.yml):

Single-node cluster (development mode)
Security disabled for local development
Persistent data volume: opensearch-data
Memory: 2GB (adjustable)

OpenSearch Dashboards:

Auto-connects to OpenSearch
Security plugin disabled
Port: 5601

Customization:

# Adjust memory limits
environment:
  - "ES_JAVA_OPTS=-Xms1g -Xmx2g"

# Enable security (production)
- DISABLE_SECURITY_PLUGIN=false

📊 Data Management

Patent Data Format

patents.json structure:

{
  "patent_id": "US123456789",
  "title": "Advanced Lithium Battery System",
  "abstract": "A novel approach to lithium battery technology...",
  "publication_date": "2023-06-15",
  "assignee": "Company Name",
  "claims": ["Claim 1", "Claim 2"],
  "references": ["Citation 1", "Citation 2"]
}

Processing Pipeline

Loading: JSON files parsed and validated
Normalization: Standardized field formats
Chunking: Large documents split into processable chunks
Embedding: Vector representations generated via Ollama
Indexing: Documents stored in OpenSearch with embeddings
Export: Processed data saved to results/ directory

Managing Indexes

from opensearch_client import get_opensearch_client, create_index_if_not_exists

# Connect to OpenSearch
client = get_opensearch_client("localhost", 9200)

# Create or recreate index with proper vector mappings
create_index_if_not_exists(client, "patents")

# Check index status
status = client.cat.indices(format="json")

# Delete index
client.indices.delete(index="patents")

🔧 Troubleshooting

Issue: Connection Refused - OpenSearch

Symptoms: Connection refused at 9200

Solutions:

# Check if Docker containers are running
docker-compose ps

# Start services
docker-compose up -d

# View logs
docker-compose logs opensearch

# Verify connectivity
curl http://localhost:9200/_cluster/health

Issue: Ollama Not Available

Symptoms: Error connecting to Ollama: Connection refused

Solutions:

# Verify Ollama is running
curl http://localhost:11434/api/tags

# Start Ollama service
ollama serve

# Check available models
ollama list

# Pull required models if missing
ollama pull llama2
ollama pull nomic-embed-text

Issue: Index Not Found

Symptoms: index_not_found_exception

Solutions:

# Re-run data ingestion
python ingestion.py

# Verify index exists
curl http://localhost:9200/_cat/indices

# Check index mapping
curl http://localhost:9200/patents/_mapping

Issue: Out of Memory

Symptoms: Container crashes, Python process killed

Solutions:

# Increase Docker memory allocation
# Edit docker-compose.yml:
  mem_limit: 4g

# Or set system limits:
# Windows: Docker Desktop → Settings → Resources
# Linux: docker update -m 4g opensearch

# Restart services
docker-compose restart

Issue: Slow Search Performance

Causes & Solutions:

Large dataset: Optimize embeddings, increase batch size
Undersized cluster: Add more nodes (production)
Poor network: Use persistent connections, connection pooling
Index not refreshed: Force refresh: curl -X POST http://localhost:9200/patents/_refresh

📈 Performance Optimization

Ingestion Optimization

Batch processing of embeddings (default: 100 documents)
Parallel index updates with multiple threads
Incremental indexing for new data

Search Optimization

Query result caching
Vector similarity optimization using HNSW
Index refresh scheduling

Configuration Tuning

# Adjust batch sizes in ingestion.py
BATCH_SIZE = 200

# Modify search parameters in patent_search_tools.py
TOP_K = 50  # Return more results
VECTOR_K = 20  # KNN neighbors

🔐 Security Considerations

Development vs. Production

Development (Current Setup):

Security plugins disabled
Admin credentials: admin/admin
Single-node cluster
No SSL/TLS encryption

Production Recommendations:

Enable OpenSearch security plugins
Use strong passwords
Configure SSL/TLS
Multi-node cluster setup
Authentication & authorization
Data encryption at rest
Network isolation

Data Privacy

All processing occurs locally
No data sent to external APIs (except optional SERP API)
Embeddings generated on-premise
Models run locally on Ollama

📚 API Reference

Patent Search Functions

# Semantic Search
semantic_search(query_text: str, top_k: int = 20) → List[Dict]

# Keyword Search
keyword_search(query_text: str, top_k: int = 20) → List[Dict]

# Hybrid Search
hybrid_search(query_text: str, top_k: int = 20) → List[Dict]

# Iterative Search
iterative_search(query_text: str, top_k: int = 20, iterations: int = 3) → List[Dict]

OpenSearch Client Functions

# Get connected client
get_opensearch_client(host: str, port: int) → OpenSearch

# Create index with vector mappings
create_index_if_not_exists(client: OpenSearch, index_name: str) → None

# Index document
index_document(client: OpenSearch, index: str, doc_id: str, body: Dict) → None

# Search
search(client: OpenSearch, index: str, query: Dict) → Dict

Embedding Functions

# Generate embedding for text
get_embedding(text: str, model: str = "nomic-embed-text") → List[float]

# Batch generate embeddings
batch_embeddings(texts: List[str]) → List[List[float]]

🚀 Advanced Topics

Extending the CrewAI Agents

Create custom agents in patent_crew.py:

from crewai import Agent, Task

class MyCustomAgent(Agent):
    role = "Custom Analyst"
    goal = "Analyze specific patent aspects"
    backstory = "Expert in specific domain..."

# Add to crew
crew = Crew(
    agents=[researcher, trend_analyst, custom_agent],
    tasks=[...],
    process=Process.hierarchical
)

Custom Search Strategies

Implement in patent_search_tools.py:

def custom_search(query_text, top_k=20, **kwargs):
    # Your custom logic here
    client = get_opensearch_client("localhost", 9200)
    # Build and execute custom query
    return results

Integration with External Systems

# Example: Connect to external patent database
from information_collector import fetch_external_patents

patents = fetch_external_patents(query="battery technology")
# Process and index

📋 Requirements & Dependencies

Core Dependencies

opensearch-py: OpenSearch Python client
crewai: Multi-agent orchestration framework
langchain: LLM chain building
langchain-ollama: Ollama integration
python-dotenv: Environment variable management
requests: HTTP client
tiktoken: Token counting

Development Dependencies

jupyter/jupyterlab: Interactive notebook
pytest: Testing framework
black: Code formatter
pylint: Code linter

System Requirements

RAM: 8GB minimum (16GB+ recommended)
Storage: 20GB+ for Docker images and data
CPU: Multi-core recommended for parallel processing
Network: Docker networking for container communication

License

This project is provided as-is for research and development purposes. Please include proper attribution when using this code.

Contributing

Contributions are welcome! To contribute:

Fork the repository
Create a feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

Development Guidelines

Write clean, documented code
Follow PEP 8 style guidelines
Add tests for new features
Update documentation
Use meaningful commit messages

Reporting Issues

When reporting bugs, please include:

System information (OS, Python version)
Error messages and traceback
Steps to reproduce
Expected vs. actual behavior

Support & Contact

For questions, issues, or suggestions:

Open an issue on GitHub
Check existing issues for solutions
Review troubleshooting section above
Check OpenSearch Dashboards for status

Acknowledgments

OpenSearch Project: Powerful search and analytics engine
CrewAI: Multi-agent orchestration framework
Ollama: Local LLM capabilities
LangChain: LLM integration framework
Patent Data Sources: USPTO and related patent databases

Additional Resources

Official Documentation

Tutorials & Guides

Vector Search Fundamentals
Patent Data Analysis Best Practices
Multi-Agent System Design Patterns
Local LLM Deployment Guide

Related Projects

Patent analysis systems
RAG implementations
CrewAI example projects
OpenSearch use cases

Roadmap

Planned Features

Advanced citation network analysis
Technology trend visualization dashboards
Batch processing optimization
Multi-language patent support
Real-time patent feed integration
Collaborative analysis features
Export to multiple formats (PDF, Excel, etc.)
REST API endpoint

Performance Improvements

Integration Opportunities

Elasticsearch compatibility
Cloud deployment options
API gateway integration
Workflow automation tools

Last Updated: January 2026 Version: 1.0.0 Status: Active Development

Name		Name	Last commit message	Last commit date
Latest commit History 15 Commits
files		files
results		results
.gitignore		.gitignore
README.md		README.md
agentic_rag.py		agentic_rag.py
dev.ipynb		dev.ipynb
docker-compose.yml		docker-compose.yml
embedding.py		embedding.py
helper.py		helper.py
information_collector.py		information_collector.py
ingestion.py		ingestion.py
opensearch_client.py		opensearch_client.py
patent_analysis_20260118_075909.txt		patent_analysis_20260118_075909.txt
patent_analysis_20260118_080144.txt		patent_analysis_20260118_080144.txt
patent_analysis_20260118_192222.txt		patent_analysis_20260118_192222.txt
patent_crew.py		patent_crew.py
patent_search_tools.py		patent_search_tools.py

Folders and files

Latest commit

History

Repository files navigation

RAG Patent Analysis System

🎯 Project Overview

Key Features

📁 Project Structure

📊 Data Files

🚀 Setup & Installation

Prerequisites

Installation Steps

Step 1: Clone and Setup Environment

Step 2: Install Python Dependencies

Step 3: Setup Environment Variables

Step 4: Start Infrastructure Services

Step 5: Setup Ollama Models

Step 6: Ingest Patent Data

💻 Usage Guide

Interactive Patent Analysis CLI

Search Operations

1. Semantic Search

2. Keyword Search

3. Hybrid Search

4. Iterative Search

Development Notebook

Advanced Usage: CrewAI Agent System

🏗️ System Architecture

Component Overview

Core Components

1. OpenSearch Backend

2. Ollama Local LLM

3. CrewAI Multi-Agent System

4. Search Pipeline

Data Flow

Ingestion Pipeline

Analysis Pipeline

⚙️ Configuration

Environment Variables (.env file)

Docker Services Configuration

📊 Data Management

Patent Data Format

Processing Pipeline

Managing Indexes

🔧 Troubleshooting

Issue: Connection Refused - OpenSearch

Issue: Ollama Not Available

Issue: Index Not Found

Issue: Out of Memory

Issue: Slow Search Performance

📈 Performance Optimization

Ingestion Optimization

Search Optimization

Configuration Tuning

🔐 Security Considerations

Development vs. Production

Data Privacy

📚 API Reference

Patent Search Functions

OpenSearch Client Functions

Embedding Functions

🚀 Advanced Topics

Extending the CrewAI Agents

Custom Search Strategies

Integration with External Systems

📋 Requirements & Dependencies

Core Dependencies

Development Dependencies

System Requirements

License

Contributing

Development Guidelines

Reporting Issues

Support & Contact

Acknowledgments

Additional Resources

Official Documentation

Tutorials & Guides

Related Projects

Roadmap