First commit

Dockerfile

@@ -1,21 +1,40 @@
+# Use Python 3.9 slim image as base
 FROM python:3.9-slim
 
+# Set working directory
 WORKDIR /app
 
+# Install system dependencies needed for PDF processing and matplotlib
 RUN apt-get update && apt-get install -y \
     build-essential \
     curl \
     software-properties-common \
     git \
+    libpoppler-cpp-dev \
+    pkg-config \
+    poppler-utils \
     && rm -rf /var/lib/apt/lists/*
 
-COPY requirements.txt ./
-COPY src/ ./src/
+# Copy requirements first for better Docker layer caching
+COPY requirements.txt .
 
-RUN pip3 install -r requirements.txt
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
 
-EXPOSE 8501
+# Copy the entire application
+COPY . .
 
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+# Set Python path to include the app directory
+ENV PYTHONPATH="${PYTHONPATH}:/app"
 
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+# Create necessary directories and set permissions
+RUN mkdir -p /tmp && chmod 777 /tmp
+
+# Expose port 7860 for Hugging Face Spaces
+EXPOSE 7860
+
+# Health check
+HEALTHCHECK CMD curl --fail http://localhost:7860/_stcore/health
+
+# Command to run the Streamlit app
+CMD ["streamlit", "run", "app.py", "--server.address=0.0.0.0", "--server.port=7860", "--browser.gatherUsageStats=false", "--server.headless=true"]

README.md

@@ -1,20 +1,284 @@
 ---
-title: Generate Knowledge Graphs
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: Use LLM to generate knowledge graphs from your input data.
 license: mit
+title: Generate Knowledge Graphs
+sdk: streamlit
+emoji: 📉
+colorFrom: indigo
+colorTo: pink
+short_description: Use LLM to generate a knowledge graph from your input data.
 ---
+# 🕸️ Knowledge Graph Extraction App
+
+A complete knowledge graph extraction application using LLMs via OpenRouter, available in both Gradio and Streamlit versions.
+
+## 🚀 Features
+
+- **Multi-format Document Support**: PDF, TXT, DOCX, JSON files up to 10MB
+- **LLM-powered Extraction**: Uses OpenRouter API with free models (Gemma-2-9B, Llama-3.1-8B)
+- **Smart Entity Detection**: Automatically identifies people, organizations, locations, concepts, events, and objects
+- **Importance Scoring**: LLM evaluates entity importance from 0.0 to 1.0
+- **Interactive Visualization**: Multiple graph layout algorithms with filtering options
+- **Batch Processing**: Optional processing of multiple documents together
+- **Export Capabilities**: JSON, GraphML, and GEXF formats
+- **Real-time Statistics**: Graph metrics and centrality analysis
+
+## 📁 Project Structure
+
+```
+knowledge-graphs/
+├── app.py                    # Main Gradio application (legacy)
+├── app_streamlit.py          # Main Streamlit application (recommended)
+├── run_streamlit.py          # Simple launcher script
+├── requirements.txt          # Python dependencies
+├── README.md                # Project documentation
+├── .env.example             # Environment variables template
+├── config/
+│   └── settings.py          # Configuration management
+└── src/
+    ├── document_processor.py # Document loading and chunking
+    ├── llm_extractor.py      # LLM-based entity extraction
+    ├── graph_builder.py      # NetworkX graph construction
+    └── visualizer.py         # Graph visualization and export
+```
+
+## 🔧 Installation & Setup
+
+### Option 1: Streamlit Version (Recommended)
+
+The Streamlit version is more stable and has better file handling.
+
+**Quick Start:**
+```bash
+python run_streamlit.py
+```
+
+**Manual Setup:**
+1. **Install dependencies**:
+```bash
+pip install -r requirements.txt
+```
+
+2. **Run the Streamlit app**:
+```bash
+streamlit run app_streamlit.py --server.address 0.0.0.0 --server.port 8501
+```
+
+The app will be available at `http://localhost:8501`
+
+### Option 2: Gradio Version (Legacy)
+
+The Gradio version may have some file caching issues but is provided for compatibility.
+
+1. **Install dependencies**:
+```bash
+pip install -r requirements.txt
+```
+
+2. **Set up environment variables** (optional):
+```bash
+cp .env.example .env
+# Edit .env and add your OpenRouter API key
+```
+
+3. **Run the application**:
+```bash
+python app.py
+```
+
+The app will be available at `http://localhost:7860`
+
+### HuggingFace Spaces Deployment
+
+For **Streamlit deployment**:
+1. Create a new Space on [HuggingFace Spaces](https://huggingface.co/spaces)
+2. Choose "Streamlit" as the SDK
+3. Upload `app_streamlit.py` as `app.py` (HF Spaces expects this name)
+4. Upload all other project files maintaining directory structure
+
+For **Gradio deployment**:
+1. Create a new Space with "Gradio" as the SDK
+2. Upload `app.py` and all other files
+3. Note: May experience file handling issues
+
+## 🔑 API Configuration
+
+### Getting OpenRouter API Key
+
+1. Visit [OpenRouter.ai](https://openrouter.ai)
+2. Sign up for a free account
+3. Navigate to API Keys section
+4. Generate a new API key
+5. Copy the key and use it in the application
+
+### Free Models Used
+
+- **Primary**: `google/gemma-2-9b-it:free`
+- **Backup**: `meta-llama/llama-3.1-8b-instruct:free`
+
+These models are specifically chosen to minimize API costs while maintaining quality.
+
+## 📖 Usage Guide
+
+### Basic Workflow
+
+1. **Upload Documents**: 
+   - Select one or more files (PDF, TXT, DOCX, JSON)
+   - Toggle batch mode for multiple document processing
+
+2. **Configure API**:
+   - Enter your OpenRouter API key
+   - Key is stored temporarily for the session
+
+3. **Customize Settings**:
+   - Choose graph layout algorithm
+   - Toggle label visibility options
+   - Set minimum importance threshold
+   - Select entity types to include
+
+4. **Extract Knowledge Graph**:
+   - Click "Extract Knowledge Graph" button
+   - Monitor progress through the status updates
+   - View results in multiple tabs
+
+5. **Explore Results**:
+   - **Graph Visualization**: Interactive graph with colored nodes by entity type
+   - **Statistics**: Detailed metrics about the graph structure
+   - **Entities**: Complete list of extracted entities with details
+   - **Central Nodes**: Most important entities based on centrality measures
+
+6. **Export Data**:
+   - Choose export format (JSON, GraphML, GEXF)
+   - Download structured graph data
+
+### Advanced Features
+
+#### Entity Types
+- **PERSON**: Individuals mentioned in the text
+- **ORGANIZATION**: Companies, institutions, groups
+- **LOCATION**: Places, addresses, geographical entities
+- **CONCEPT**: Abstract ideas, theories, methodologies
+- **EVENT**: Specific occurrences, meetings, incidents
+- **OBJECT**: Physical items, products, artifacts
+
+#### Relationship Types
+- **works_at**: Employment relationships
+- **located_in**: Geographical associations
+- **part_of**: Hierarchical relationships
+- **causes**: Causal relationships
+- **related_to**: General associations
+
+#### Filtering Options
+- **Importance Threshold**: Show only entities above specified importance score
+- **Entity Types**: Filter by specific entity categories
+- **Layout Algorithms**: Spring, circular, shell, Kamada-Kawai, random
+
+## 🛠️ Technical Details
+
+### Architecture Components
+
+1. **Document Processing**: 
+   - Multi-format file parsing
+   - Intelligent text chunking with overlap
+   - File size validation
+
+2. **LLM Integration**:
+   - OpenRouter API integration
+   - Structured prompt engineering
+   - Error handling and fallback models
+
+3. **Graph Processing**:
+   - NetworkX-based graph construction
+   - Entity deduplication and standardization
+   - Relationship validation
+
+4. **Visualization**:
+   - Matplotlib-based static graphs
+   - Interactive HTML visualizations
+   - Multiple export formats
+
+### Configuration Options
+
+All settings can be modified in `config/settings.py`:
+
+- **Chunk Size**: Default 2000 characters
+- **Chunk Overlap**: Default 200 characters  
+- **Max File Size**: Default 10MB
+- **Max Entities**: Default 100 per extraction
+- **Max Relationships**: Default 200 per extraction
+- **Importance Threshold**: Default 0.3
+
+### Differences Between Versions
+
+**Streamlit Version Advantages:**
+- More reliable file handling
+- Better progress indicators
+- Cleaner UI with sidebar configuration
+- More stable caching system
+- Built-in download functionality
+
+**Gradio Version Advantages:**
+- Simpler deployment to HF Spaces
+- More compact interface
+- Familiar for ML practitioners
+
+## 🔒 Security & Privacy
+
+- API keys are not stored permanently
+- Files are processed temporarily and discarded
+- No data is retained between sessions
+- All processing happens server-side
+
+## 🐛 Troubleshooting
+
+### Common Issues
+
+1. **"OpenRouter API key is required"**:
+   - Ensure you've entered a valid API key
+   - Check the key has sufficient credits
+
+2. **"No entities extracted"**:
+   - Document may be too short or unstructured
+   - Try lowering the importance threshold
+   - Check if the document contains meaningful text
+
+3. **File upload issues (Gradio version)**:
+   - Known issue with Gradio's file caching system
+   - Try the Streamlit version instead
+   - Ensure files are valid and not corrupted
+
+4. **Segmentation fault (local development)**:
+   - Usually related to matplotlib backend
+   - Try setting `MPLBACKEND=Agg` environment variable
+   - Install GUI toolkit if running locally with display
+
+5. **Module import errors**:
+   - Ensure all requirements are installed: `pip install -r requirements.txt`
+   - Check Python version compatibility (3.8+)
+
+### Performance Tips
+
+- Use batch mode for related documents
+- Adjust chunk size for very long documents
+- Lower importance threshold for sparse documents
+- Use simpler layout algorithms for large graphs
+
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Test with both Streamlit and Gradio versions if applicable
+5. Add tests if applicable
+6. Submit a pull request
+
+## 📄 License
 
-# Welcome to Streamlit!
+This project is licensed under the MIT License - see the LICENSE file for details.
 
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
+## 🙏 Acknowledgments
 
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+- [OpenRouter](https://openrouter.ai) for LLM API access
+- [Streamlit](https://streamlit.io) for the modern web interface framework
+- [Gradio](https://gradio.app) for the ML-focused web interface
+- [NetworkX](https://networkx.org) for graph processing
+- [HuggingFace Spaces](https://huggingface.co/spaces) for hosting

README_HF_SPACES.md

@@ -0,0 +1,69 @@
+# Hugging Face Spaces Deployment
+
+This guide explains how to deploy the Knowledge Graph Extraction app to Hugging Face Spaces using the provided Dockerfile.
+
+## Deployment Steps
+
+### 1. Create a New Space
+1. Go to [Hugging Face Spaces](https://huggingface.co/spaces)
+2. Click "Create new Space"
+3. Choose a name for your space
+4. Select "Docker" as the SDK
+5. Choose "Public" or "Private" visibility
+
+### 2. Upload Files
+Upload all the project files to your space, including:
+- `Dockerfile`
+- `app_streamlit.py`
+- `requirements.txt`
+- `src/` directory with all modules
+- `config/` directory
+- `.env.example` (optional)
+
+### 3. Environment Variables
+In your Hugging Face Space settings, add the following environment variable:
+- `OPENROUTER_API_KEY`: Your OpenRouter API key (optional, users can also input it in the app)
+
+### 4. Docker Configuration
+The Dockerfile is already optimized for HF Spaces with:
+- Port 7860 (HF Spaces standard)
+- Proper system dependencies for PDF processing
+- Streamlit configured for headless deployment
+- Health checks enabled
+
+### 5. App Features
+Once deployed, users can:
+- Upload PDF, TXT, DOCX, or JSON documents
+- Enter their OpenRouter API key in the sidebar
+- Extract knowledge graphs using LLM processing
+- Visualize graphs with various layout options
+- Filter entities by type and importance
+- Export graphs in JSON, GraphML, or GEXF formats
+
+## Technical Details
+
+### Dependencies
+The Dockerfile installs:
+- System packages: `poppler-utils`, `libpoppler-cpp-dev` for PDF processing
+- Python packages: All from `requirements.txt`
+
+### File Limits
+- Default Streamlit file upload limit: 200MB
+- Recommended per-file limit in config: 10MB
+
+### Models Used
+- Primary: `qwen/qwen3-32b` (free model via OpenRouter)
+- The app uses cost-effective models to minimize API costs
+
+## Usage Notes
+- Users need their own OpenRouter API key
+- Processing time depends on document size and complexity
+- The app supports batch processing of multiple documents
+- Temporary files are automatically cleaned up after processing
+
+## Troubleshooting
+If deployment fails:
+1. Check that all files are uploaded correctly
+2. Verify the Dockerfile syntax
+3. Check HF Spaces logs for specific error messages
+4. Ensure requirements.txt contains all necessary dependencies

app.py

@@ -0,0 +1,338 @@
+import streamlit as st
+import tempfile
+import os
+import json
+from typing import List, Dict, Any, Optional, Tuple
+import traceback
+
+# Import our modules
+from src.document_processor import DocumentProcessor
+from src.llm_extractor import LLMExtractor
+from src.graph_builder import GraphBuilder
+from src.visualizer import GraphVisualizer
+from config.settings import Config
+
+# Page config
+st.set_page_config(
+    page_title="Knowledge Graph Extraction",
+    page_icon="🕸️",
+    layout="wide"
+)
+
+# Initialize components
+@st.cache_resource
+def initialize_components():
+    config = Config()
+    doc_processor = DocumentProcessor()
+    llm_extractor = LLMExtractor()
+    graph_builder = GraphBuilder()
+    visualizer = GraphVisualizer()
+    return config, doc_processor, llm_extractor, graph_builder, visualizer
+
+config, doc_processor, llm_extractor, graph_builder, visualizer = initialize_components()
+
+def process_uploaded_files(uploaded_files, api_key, batch_mode, layout_type, 
+                          show_labels, show_edge_labels, min_importance, entity_types_filter):
+    """Process uploaded files and extract knowledge graph."""
+    
+    try:
+        # Update API key
+        if api_key.strip():
+            config.OPENROUTER_API_KEY = api_key.strip()
+            llm_extractor.config.OPENROUTER_API_KEY = api_key.strip()
+            llm_extractor.headers["Authorization"] = f"Bearer {api_key.strip()}"
+        
+        if not config.OPENROUTER_API_KEY:
+            st.error("❌ OpenRouter API key is required")
+            return None
+        
+        if not uploaded_files:
+            st.error("❌ Please upload at least one file")
+            return None
+        
+        progress_bar = st.progress(0)
+        status_text = st.empty()
+        
+        status_text.text("Loading documents...")
+        progress_bar.progress(0.1)
+        
+        # Save uploaded files to temporary location
+        file_paths = []
+        for uploaded_file in uploaded_files:
+            # Create temporary file
+            with tempfile.NamedTemporaryFile(delete=False, suffix=f"_{uploaded_file.name}") as tmp_file:
+                tmp_file.write(uploaded_file.getvalue())
+                file_paths.append(tmp_file.name)
+        
+        # Process documents
+        doc_results = doc_processor.process_documents(file_paths, batch_mode)
+        
+        # Clean up temporary files
+        for file_path in file_paths:
+            try:
+                os.unlink(file_path)
+            except:
+                pass
+        
+        # Check for errors
+        failed_files = [r for r in doc_results if r['status'] == 'error']
+        if failed_files:
+            error_msg = "Failed to process files:\n" + "\n".join([f"- {r['file_path']}: {r['error']}" for r in failed_files])
+            if len(failed_files) == len(doc_results):
+                st.error(f"❌ {error_msg}")
+                return None
+        
+        status_text.text("Extracting entities and relationships...")
+        progress_bar.progress(0.3)
+        
+        # Extract entities and relationships
+        all_entities = []
+        all_relationships = []
+        extraction_errors = []
+        
+        for doc_result in doc_results:
+            if doc_result['status'] == 'success':
+                extraction_result = llm_extractor.process_chunks(doc_result['chunks'])
+                
+                if extraction_result.get('errors'):
+                    extraction_errors.extend(extraction_result['errors'])
+                
+                all_entities.extend(extraction_result.get('entities', []))
+                all_relationships.extend(extraction_result.get('relationships', []))
+        
+        if not all_entities:
+            error_msg = "No entities extracted from documents"
+            if extraction_errors:
+                error_msg += f"\nExtraction errors: {'; '.join(extraction_errors[:3])}"
+            st.error(f"❌ {error_msg}")
+            return None
+        
+        status_text.text("Building knowledge graph...")
+        progress_bar.progress(0.6)
+        
+        # Build graph
+        graph = graph_builder.build_graph(all_entities, all_relationships)
+        
+        if not graph.nodes():
+            st.error("❌ No valid knowledge graph could be built")
+            return None
+        
+        status_text.text("Applying filters...")
+        progress_bar.progress(0.7)
+        
+        # Apply filters
+        filtered_graph = graph
+        if entity_types_filter:
+            filtered_graph = graph_builder.filter_graph(
+                entity_types=entity_types_filter,
+                min_importance=min_importance
+            )
+        elif min_importance > 0:
+            filtered_graph = graph_builder.filter_graph(min_importance=min_importance)
+        
+        if not filtered_graph.nodes():
+            st.error("❌ No entities remain after applying filters")
+            return None
+        
+        status_text.text("Generating visualizations...")
+        progress_bar.progress(0.8)
+        
+        # Generate graph visualization
+        graph_image_path = visualizer.visualize_graph(
+            filtered_graph,
+            layout_type=layout_type,
+            show_labels=show_labels,
+            show_edge_labels=show_edge_labels
+        )
+        
+        # Get statistics
+        stats = graph_builder.get_graph_statistics()
+        stats_summary = visualizer.create_statistics_summary(filtered_graph, stats)
+        
+        # Get entity list
+        entity_list = visualizer.create_entity_list(filtered_graph)
+        
+        # Get central nodes
+        central_nodes = graph_builder.get_central_nodes()
+        central_nodes_text = "## Most Central Entities\n\n"
+        for i, (node, score) in enumerate(central_nodes, 1):
+            central_nodes_text += f"{i}. **{node}** (centrality: {score:.3f})\n"
+        
+        status_text.text("Complete!")
+        progress_bar.progress(1.0)
+        
+        # Success message
+        success_msg = f"✅ Successfully processed {len([r for r in doc_results if r['status'] == 'success'])} document(s)"
+        if failed_files:
+            success_msg += f"\n⚠️ {len(failed_files)} file(s) failed to process"
+        if extraction_errors:
+            success_msg += f"\n⚠️ {len(extraction_errors)} extraction error(s) occurred"
+        
+        return {
+            'success_msg': success_msg,
+            'graph_image_path': graph_image_path,
+            'stats_summary': stats_summary,
+            'entity_list': entity_list,
+            'central_nodes_text': central_nodes_text,
+            'graph': filtered_graph
+        }
+        
+    except Exception as e:
+        st.error(f"❌ Error: {str(e)}")
+        st.error(f"Full traceback:\n{traceback.format_exc()}")
+        return None
+
+# Main app
+def main():
+    st.title("🕸️ Knowledge Graph Extraction")
+    st.markdown("""
+    Upload documents and extract knowledge graphs using LLMs via OpenRouter.
+    Supports PDF, TXT, DOCX, and JSON files.
+    """)
+    
+    # Sidebar for configuration
+    with st.sidebar:
+        st.header("📁 Document Upload")
+        uploaded_files = st.file_uploader(
+            "Choose files",
+            type=['pdf', 'txt', 'docx', 'json'],
+            accept_multiple_files=True
+        )
+        
+        batch_mode = st.checkbox(
+            "Batch Processing Mode",
+            value=False,
+            help="Process multiple files together"
+        )
+        
+        st.header("🔑 API Configuration")
+        api_key = st.text_input(
+            "OpenRouter API Key",
+            type="password",
+            placeholder="Enter your OpenRouter API key",
+            help="Get your key at openrouter.ai"
+        )
+        
+        st.header("🎛️ Visualization Settings")
+        layout_type = st.selectbox(
+            "Layout Algorithm",
+            options=visualizer.get_layout_options(),
+            index=0
+        )
+        
+        show_labels = st.checkbox("Show Node Labels", value=True)
+        show_edge_labels = st.checkbox("Show Edge Labels", value=False)
+        
+        st.header("🔍 Filtering Options")
+        min_importance = st.slider(
+            "Minimum Entity Importance",
+            min_value=0.0,
+            max_value=1.0,
+            value=0.3,
+            step=0.1
+        )
+        
+        entity_types_filter = st.multiselect(
+            "Entity Types Filter",
+            options=[],
+            help="Filter will be populated after processing"
+        )
+        
+        process_button = st.button("🚀 Extract Knowledge Graph", type="primary")
+    
+    # Main content area
+    if process_button and uploaded_files:
+        with st.spinner("Processing..."):
+            result = process_uploaded_files(
+                uploaded_files, api_key, batch_mode, layout_type,
+                show_labels, show_edge_labels, min_importance, entity_types_filter
+            )
+        
+        if result:
+            # Store results in session state
+            st.session_state['result'] = result
+            
+            # Display success message
+            st.success(result['success_msg'])
+            
+            # Create tabs for results
+            tab1, tab2, tab3, tab4 = st.tabs(["📈 Graph Visualization", "📋 Statistics", "📝 Entities", "🎯 Central Nodes"])
+            
+            with tab1:
+                if result['graph_image_path'] and os.path.exists(result['graph_image_path']):
+                    st.image(result['graph_image_path'], caption="Knowledge Graph", use_column_width=True)
+                else:
+                    st.error("Failed to generate graph visualization")
+            
+            with tab2:
+                st.markdown(result['stats_summary'])
+            
+            with tab3:
+                st.markdown(result['entity_list'])
+            
+            with tab4:
+                st.markdown(result['central_nodes_text'])
+            
+            # Export options
+            st.header("💾 Export Options")
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                export_format = st.selectbox(
+                    "Export Format",
+                    options=["json", "graphml", "gexf"],
+                    index=0
+                )
+            
+            with col2:
+                if st.button("📥 Export Graph"):
+                    try:
+                        export_data = graph_builder.export_graph(export_format)
+                        st.text_area("Export Data", value=export_data, height=300)
+                        
+                        # Download button
+                        st.download_button(
+                            label=f"Download {export_format.upper()} file",
+                            data=export_data,
+                            file_name=f"knowledge_graph.{export_format}",
+                            mime="application/octet-stream"
+                        )
+                    except Exception as e:
+                        st.error(f"Export failed: {str(e)}")
+    
+    elif process_button and not uploaded_files:
+        st.warning("Please upload at least one file before processing.")
+    
+    # Instructions
+    st.header("📚 Instructions")
+    
+    with st.expander("How to use this app"):
+        st.markdown("""
+        1. **Upload Documents**: Select one or more files (PDF, TXT, DOCX, JSON) using the file uploader in the sidebar
+        2. **Enter API Key**: Get a free API key from [OpenRouter](https://openrouter.ai) and enter it in the sidebar
+        3. **Configure Settings**: Adjust visualization and filtering options in the sidebar
+        4. **Extract Graph**: Click the "Extract Knowledge Graph" button and wait for processing
+        5. **Explore Results**: View the graph, statistics, and entity details in the tabs
+        6. **Export**: Download the graph data in various formats
+        """)
+    
+    with st.expander("Features"):
+        st.markdown("""
+        - **Multi-format Support**: PDF, TXT, DOCX, JSON files
+        - **Batch Processing**: Process multiple documents together
+        - **Smart Extraction**: Uses LLM to identify important entities and relationships
+        - **Interactive Filtering**: Filter by entity type and importance
+        - **Multiple Layouts**: Various graph layout algorithms
+        - **Export Options**: JSON, GraphML, GEXF formats
+        - **Free Models**: Uses cost-effective OpenRouter models
+        """)
+    
+    with st.expander("Notes"):
+        st.markdown("""
+        - File size limit: 10MB per file
+        - Free OpenRouter models are used to minimize costs
+        - Processing time depends on document size and complexity
+        """)
+
+if __name__ == "__main__":
+    main()

app_streamlit.py

@@ -0,0 +1,377 @@
+import streamlit as st
+import tempfile
+import os
+import json
+from typing import List, Dict, Any, Optional, Tuple
+import traceback
+
+# Import our modules
+from src.document_processor import DocumentProcessor
+from src.llm_extractor import LLMExtractor
+from src.graph_builder import GraphBuilder
+from src.visualizer import GraphVisualizer
+from config.settings import Config
+
+# Page config
+st.set_page_config(
+    page_title="Knowledge Graph Extraction",
+    page_icon="🕸️",
+    layout="wide"
+)
+
+# Initialize components
+@st.cache_resource
+def initialize_components():
+    config = Config()
+    doc_processor = DocumentProcessor()
+    llm_extractor = LLMExtractor()
+    graph_builder = GraphBuilder()
+    visualizer = GraphVisualizer()
+    return config, doc_processor, llm_extractor, graph_builder, visualizer
+
+config, doc_processor, llm_extractor, graph_builder, visualizer = initialize_components()
+
+def process_uploaded_files(uploaded_files, api_key, batch_mode, visualization_type, layout_type, 
+                          show_labels, show_edge_labels, min_importance, entity_types_filter):
+    """Process uploaded files and extract knowledge graph."""
+    
+    try:
+        # Update API key
+        if api_key.strip():
+            config.OPENROUTER_API_KEY = api_key.strip()
+            llm_extractor.config.OPENROUTER_API_KEY = api_key.strip()
+            llm_extractor.headers["Authorization"] = f"Bearer {api_key.strip()}"
+        
+        if not config.OPENROUTER_API_KEY:
+            st.error("❌ OpenRouter API key is required")
+            return None
+        
+        if not uploaded_files:
+            st.error("❌ Please upload at least one file")
+            return None
+        
+        progress_bar = st.progress(0)
+        status_text = st.empty()
+        
+        status_text.text("Loading documents...")
+        progress_bar.progress(0.1)
+        
+        # Save uploaded files to temporary location
+        file_paths = []
+        for uploaded_file in uploaded_files:
+            # Create temporary file
+            with tempfile.NamedTemporaryFile(delete=False, suffix=f"_{uploaded_file.name}") as tmp_file:
+                tmp_file.write(uploaded_file.getvalue())
+                file_paths.append(tmp_file.name)
+        
+        # Process documents
+        doc_results = doc_processor.process_documents(file_paths, batch_mode)
+        
+        # Clean up temporary files
+        for file_path in file_paths:
+            try:
+                os.unlink(file_path)
+            except:
+                pass
+        
+        # Check for errors
+        failed_files = [r for r in doc_results if r['status'] == 'error']
+        if failed_files:
+            error_msg = "Failed to process files:\n" + "\n".join([f"- {r['file_path']}: {r['error']}" for r in failed_files])
+            if len(failed_files) == len(doc_results):
+                st.error(f"❌ {error_msg}")
+                return None
+        
+        status_text.text("Extracting entities and relationships...")
+        progress_bar.progress(0.3)
+        
+        # Extract entities and relationships
+        all_entities = []
+        all_relationships = []
+        extraction_errors = []
+        
+        for doc_result in doc_results:
+            if doc_result['status'] == 'success':
+                extraction_result = llm_extractor.process_chunks(doc_result['chunks'])
+                
+                if extraction_result.get('errors'):
+                    extraction_errors.extend(extraction_result['errors'])
+                
+                all_entities.extend(extraction_result.get('entities', []))
+                all_relationships.extend(extraction_result.get('relationships', []))
+        
+        if not all_entities:
+            error_msg = "No entities extracted from documents"
+            if extraction_errors:
+                error_msg += f"\nExtraction errors: {'; '.join(extraction_errors[:3])}"
+            st.error(f"❌ {error_msg}")
+            return None
+        
+        status_text.text("Building knowledge graph...")
+        progress_bar.progress(0.6)
+        
+        # Build graph
+        graph = graph_builder.build_graph(all_entities, all_relationships)
+        
+        if not graph.nodes():
+            st.error("❌ No valid knowledge graph could be built")
+            return None
+        
+        status_text.text("Applying filters...")
+        progress_bar.progress(0.7)
+        
+        # Apply filters
+        filtered_graph = graph
+        if entity_types_filter:
+            filtered_graph = graph_builder.filter_graph(
+                entity_types=entity_types_filter,
+                min_importance=min_importance
+            )
+        elif min_importance > 0:
+            filtered_graph = graph_builder.filter_graph(min_importance=min_importance)
+        
+        if not filtered_graph.nodes():
+            st.error("❌ No entities remain after applying filters")
+            return None
+        
+        status_text.text("Generating visualizations...")
+        progress_bar.progress(0.8)
+        
+        # Generate graph visualization based on type
+        if visualization_type == "plotly":
+            graph_viz = visualizer.create_plotly_interactive(filtered_graph, layout_type)
+            graph_image_path = None
+        elif visualization_type == "pyvis":
+            graph_image_path = visualizer.create_pyvis_interactive(filtered_graph, layout_type)
+            graph_viz = None
+        elif visualization_type == "vis.js":
+            graph_viz = visualizer.create_interactive_html(filtered_graph)
+            graph_image_path = None
+        else:  # matplotlib
+            graph_image_path = visualizer.visualize_graph(
+                filtered_graph,
+                layout_type=layout_type,
+                show_labels=show_labels,
+                show_edge_labels=show_edge_labels
+            )
+            graph_viz = None
+        
+        # Get statistics
+        stats = graph_builder.get_graph_statistics()
+        stats_summary = visualizer.create_statistics_summary(filtered_graph, stats)
+        
+        # Get entity list
+        entity_list = visualizer.create_entity_list(filtered_graph)
+        
+        # Get central nodes
+        central_nodes = graph_builder.get_central_nodes()
+        central_nodes_text = "## Most Central Entities\n\n"
+        for i, (node, score) in enumerate(central_nodes, 1):
+            central_nodes_text += f"{i}. **{node}** (centrality: {score:.3f})\n"
+        
+        status_text.text("Complete!")
+        progress_bar.progress(1.0)
+        
+        # Success message
+        success_msg = f"✅ Successfully processed {len([r for r in doc_results if r['status'] == 'success'])} document(s)"
+        if failed_files:
+            success_msg += f"\n⚠️ {len(failed_files)} file(s) failed to process"
+        if extraction_errors:
+            success_msg += f"\n⚠️ {len(extraction_errors)} extraction error(s) occurred"
+        
+        return {
+            'success_msg': success_msg,
+            'graph_image_path': graph_image_path,
+            'graph_viz': graph_viz,
+            'visualization_type': visualization_type,
+            'stats_summary': stats_summary,
+            'entity_list': entity_list,
+            'central_nodes_text': central_nodes_text,
+            'graph': filtered_graph
+        }
+        
+    except Exception as e:
+        st.error(f"❌ Error: {str(e)}")
+        st.error(f"Full traceback:\n{traceback.format_exc()}")
+        return None
+
+# Main app
+def main():
+    st.title("🕸️ Knowledge Graph Extraction")
+    st.markdown("""
+    Upload documents and extract knowledge graphs using LLMs via OpenRouter.
+    Supports PDF, TXT, DOCX, and JSON files.
+    """)
+    
+    # Sidebar for configuration
+    with st.sidebar:
+        st.header("📁 Document Upload")
+        uploaded_files = st.file_uploader(
+            "Choose files",
+            type=['pdf', 'txt', 'docx', 'json'],
+            accept_multiple_files=True
+        )
+        
+        batch_mode = st.checkbox(
+            "Batch Processing Mode",
+            value=False,
+            help="Process multiple files together"
+        )
+        
+        st.header("🔑 API Configuration")
+        api_key = st.text_input(
+            "OpenRouter API Key",
+            type="password",
+            placeholder="Enter your OpenRouter API key",
+            help="Get your key at openrouter.ai"
+        )
+        
+        st.header("🎛️ Visualization Settings")
+        visualization_type = st.selectbox(
+            "Visualization Type",
+            options=visualizer.get_visualization_options(),
+            index=1,  # Default to plotly for interactivity
+            help="Choose visualization method"
+        )
+        
+        layout_type = st.selectbox(
+            "Layout Algorithm",
+            options=visualizer.get_layout_options(),
+            index=0
+        )
+        
+        show_labels = st.checkbox("Show Node Labels", value=True)
+        show_edge_labels = st.checkbox("Show Edge Labels", value=False)
+        
+        st.header("🔍 Filtering Options")
+        min_importance = st.slider(
+            "Minimum Entity Importance",
+            min_value=0.0,
+            max_value=1.0,
+            value=0.3,
+            step=0.1
+        )
+        
+        entity_types_filter = st.multiselect(
+            "Entity Types Filter",
+            options=[],
+            help="Filter will be populated after processing"
+        )
+        
+        process_button = st.button("🚀 Extract Knowledge Graph", type="primary")
+    
+    # Main content area
+    if process_button and uploaded_files:
+        with st.spinner("Processing..."):
+            result = process_uploaded_files(
+                uploaded_files, api_key, batch_mode, visualization_type, layout_type,
+                show_labels, show_edge_labels, min_importance, entity_types_filter
+            )
+        
+        if result:
+            # Store results in session state
+            st.session_state['result'] = result
+            
+            # Display success message
+            st.success(result['success_msg'])
+            
+            # Create tabs for results
+            tab1, tab2, tab3, tab4 = st.tabs(["📈 Graph Visualization", "📋 Statistics", "📝 Entities", "🎯 Central Nodes"])
+            
+            with tab1:
+                viz_type = result['visualization_type']
+                
+                if viz_type == "plotly" and result['graph_viz']:
+                    st.plotly_chart(result['graph_viz'], use_container_width=True)
+                    st.info("🎯 Interactive Plotly graph: Hover over nodes for details, drag to pan, scroll to zoom")
+                    
+                elif viz_type == "pyvis" and result['graph_image_path'] and os.path.exists(result['graph_image_path']):
+                    # Read HTML file and display
+                    with open(result['graph_image_path'], 'r', encoding='utf-8') as f:
+                        html_content = f.read()
+                    st.components.v1.html(html_content, height=600, scrolling=True)
+                    st.info("🎯 Interactive Pyvis graph: Drag nodes to rearrange, hover for details")
+                    
+                elif viz_type == "vis.js" and result['graph_viz']:
+                    st.components.v1.html(result['graph_viz'], height=600, scrolling=True)
+                    st.info("🎯 Interactive vis.js graph: Drag nodes, hover for details, use physics simulation")
+                    
+                elif viz_type == "matplotlib" and result['graph_image_path'] and os.path.exists(result['graph_image_path']):
+                    st.image(result['graph_image_path'], caption="Knowledge Graph", use_column_width=True)
+                    st.info("📊 Static matplotlib visualization")
+                    
+                else:
+                    st.error("Failed to generate graph visualization")
+            
+            with tab2:
+                st.markdown(result['stats_summary'])
+            
+            with tab3:
+                st.markdown(result['entity_list'])
+            
+            with tab4:
+                st.markdown(result['central_nodes_text'])
+            
+            # Export options
+            st.header("💾 Export Options")
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                export_format = st.selectbox(
+                    "Export Format",
+                    options=["json", "graphml", "gexf"],
+                    index=0
+                )
+            
+            with col2:
+                if st.button("📥 Export Graph"):
+                    try:
+                        export_data = graph_builder.export_graph(export_format)
+                        st.text_area("Export Data", value=export_data, height=300)
+                        
+                        # Download button
+                        st.download_button(
+                            label=f"Download {export_format.upper()} file",
+                            data=export_data,
+                            file_name=f"knowledge_graph.{export_format}",
+                            mime="application/octet-stream"
+                        )
+                    except Exception as e:
+                        st.error(f"Export failed: {str(e)}")
+    
+    elif process_button and not uploaded_files:
+        st.warning("Please upload at least one file before processing.")
+    
+    # Instructions
+    st.header("📚 Instructions")
+    
+    with st.expander("How to use this app"):
+        st.markdown("""
+        1. **Upload Documents**: Select one or more files (PDF, TXT, DOCX, JSON) using the file uploader in the sidebar
+        2. **Enter API Key**: Get a free API key from [OpenRouter](https://openrouter.ai) and enter it in the sidebar
+        3. **Configure Settings**: Adjust visualization and filtering options in the sidebar
+        4. **Extract Graph**: Click the "Extract Knowledge Graph" button and wait for processing
+        5. **Explore Results**: View the graph, statistics, and entity details in the tabs
+        6. **Export**: Download the graph data in various formats
+        """)
+    
+    with st.expander("Features"):
+        st.markdown("""
+        - **Multi-format Support**: PDF, TXT, DOCX, JSON files
+        - **Batch Processing**: Process multiple documents together
+        - **Smart Extraction**: Uses LLM to identify important entities and relationships
+        - **Interactive Filtering**: Filter by entity type and importance
+        - **Multiple Layouts**: Various graph layout algorithms
+        - **Export Options**: JSON, GraphML, GEXF formats
+        - **Free Models**: Uses cost-effective OpenRouter models
+        """)
+    
+    with st.expander("Notes"):
+        st.markdown("""
+        - File size limit: 10MB per file
+        - Free OpenRouter models are used to minimize costs
+        - Processing time depends on document size and complexity
+        """)
+
+if __name__ == "__main__":
+    main()

src/document_processor.py

@@ -0,0 +1,125 @@
+import os
+import json
+from typing import List, Dict, Any
+import pdfplumber
+from docx import Document
+from config.settings import Config
+
+class DocumentProcessor:
+    def __init__(self):
+        self.config = Config()
+    
+    def validate_file_size(self, file_path: str) -> bool:
+        """Validate file size is within limits."""
+        file_size_mb = os.path.getsize(file_path) / (1024 * 1024)
+        return file_size_mb <= self.config.MAX_FILE_SIZE_MB
+    
+    def load_document(self, file_path: str) -> str:
+        """Load document content based on file extension."""
+        if not self.validate_file_size(file_path):
+            raise ValueError(f"File size exceeds {self.config.MAX_FILE_SIZE_MB}MB limit")
+        
+        file_ext = os.path.splitext(file_path)[1].lower()
+        
+        if file_ext == '.pdf':
+            return self._load_pdf(file_path)
+        elif file_ext == '.docx':
+            return self._load_docx(file_path)
+        elif file_ext == '.txt':
+            return self._load_txt(file_path)
+        elif file_ext == '.json':
+            return self._load_json(file_path)
+        else:
+            raise ValueError(f"Unsupported file format: {file_ext}")
+    
+    def _load_pdf(self, file_path: str) -> str:
+        """Load PDF content."""
+        text = ""
+        with pdfplumber.open(file_path) as pdf:
+            for page in pdf.pages:
+                page_text = page.extract_text()
+                if page_text:
+                    text += page_text + "\n"
+        return text
+    
+    def _load_docx(self, file_path: str) -> str:
+        """Load DOCX content."""
+        doc = Document(file_path)
+        text = ""
+        for paragraph in doc.paragraphs:
+            text += paragraph.text + "\n"
+        return text
+    
+    def _load_txt(self, file_path: str) -> str:
+        """Load TXT content."""
+        with open(file_path, 'r', encoding='utf-8') as file:
+            return file.read()
+    
+    def _load_json(self, file_path: str) -> str:
+        """Load JSON content and convert to text."""
+        with open(file_path, 'r', encoding='utf-8') as file:
+            data = json.load(file)
+            return json.dumps(data, indent=2)
+    
+    def chunk_text(self, text: str) -> List[str]:
+        """Split text into overlapping chunks for processing."""
+        if len(text) <= self.config.CHUNK_SIZE:
+            return [text]
+        
+        chunks = []
+        start = 0
+        
+        while start < len(text):
+            end = start + self.config.CHUNK_SIZE
+            
+            # Try to break at sentence boundaries
+            if end < len(text):
+                # Look for sentence endings
+                sentence_end = text.rfind('.', start, end)
+                if sentence_end == -1:
+                    sentence_end = text.rfind('!', start, end)
+                if sentence_end == -1:
+                    sentence_end = text.rfind('?', start, end)
+                
+                if sentence_end != -1 and sentence_end > start + self.config.CHUNK_SIZE // 2:
+                    end = sentence_end + 1
+            
+            chunk = text[start:end].strip()
+            if chunk:
+                chunks.append(chunk)
+            
+            start = end - self.config.CHUNK_OVERLAP
+            if start >= len(text):
+                break
+        
+        return chunks
+    
+    def process_documents(self, file_paths: List[str], batch_mode: bool = False) -> List[Dict[str, Any]]:
+        """Process multiple documents."""
+        results = []
+        
+        for file_path in file_paths:
+            try:
+                content = self.load_document(file_path)
+                chunks = self.chunk_text(content)
+                
+                results.append({
+                    'file_path': file_path,
+                    'content': content,
+                    'chunks': chunks,
+                    'status': 'success'
+                })
+                
+                if not batch_mode:
+                    break  # Process only one file if not in batch mode
+                    
+            except Exception as e:
+                results.append({
+                    'file_path': file_path,
+                    'content': '',
+                    'chunks': [],
+                    'status': 'error',
+                    'error': str(e)
+                })
+        
+        return results

src/graph_builder.py

@@ -0,0 +1,234 @@
+import networkx as nx
+from typing import List, Dict, Any, Tuple
+import json
+
+class GraphBuilder:
+    def __init__(self):
+        self.graph = nx.DiGraph()  # Directed graph for relationships
+    
+    def build_graph(self, entities: List[Dict[str, Any]], relationships: List[Dict[str, Any]]) -> nx.DiGraph:
+        """Build NetworkX graph from entities and relationships."""
+        self.graph.clear()
+        
+        # Add entities as nodes
+        for entity in entities:
+            node_id = entity.get("name", "").strip()
+            if node_id:
+                self.graph.add_node(
+                    node_id,
+                    type=entity.get("type", "UNKNOWN"),
+                    importance=entity.get("importance", 0.0),
+                    description=entity.get("description", ""),
+                    size=self._calculate_node_size(entity.get("importance", 0.0))
+                )
+        
+        # Add relationships as edges
+        for relationship in relationships:
+            source = relationship.get("source", "").strip()
+            target = relationship.get("target", "").strip()
+            rel_type = relationship.get("relationship", "related_to")
+            description = relationship.get("description", "")
+            
+            if source and target and source in self.graph.nodes and target in self.graph.nodes:
+                self.graph.add_edge(
+                    source,
+                    target,
+                    relationship=rel_type,
+                    description=description,
+                    weight=1.0
+                )
+        
+        return self.graph
+    
+    def _calculate_node_size(self, importance: float) -> int:
+        """Calculate node size based on importance score."""
+        # Map importance (0.0-1.0) to node size (10-50)
+        min_size, max_size = 10, 50
+        return int(min_size + (max_size - min_size) * importance)
+    
+    def get_graph_statistics(self) -> Dict[str, Any]:
+        """Get basic statistics about the graph."""
+        if not self.graph.nodes():
+            return {
+                "num_nodes": 0,
+                "num_edges": 0,
+                "density": 0.0,
+                "is_connected": False,
+                "num_components": 0
+            }
+        
+        # Convert to undirected for connectivity analysis
+        undirected = self.graph.to_undirected()
+        
+        return {
+            "num_nodes": self.graph.number_of_nodes(),
+            "num_edges": self.graph.number_of_edges(),
+            "density": nx.density(self.graph),
+            "is_connected": nx.is_connected(undirected),
+            "num_components": nx.number_connected_components(undirected),
+            "avg_degree": sum(dict(self.graph.degree()).values()) / self.graph.number_of_nodes() if self.graph.number_of_nodes() > 0 else 0
+        }
+    
+    def get_central_nodes(self, top_k: int = 5) -> List[Tuple[str, float]]:
+        """Get most central nodes using various centrality measures."""
+        if not self.graph.nodes():
+            return []
+        
+        centralities = {}
+        
+        # Degree centrality
+        degree_centrality = nx.degree_centrality(self.graph)
+        
+        # Betweenness centrality (if graph has enough nodes)
+        if self.graph.number_of_nodes() > 2:
+            betweenness_centrality = nx.betweenness_centrality(self.graph)
+        else:
+            betweenness_centrality = {node: 0.0 for node in self.graph.nodes()}
+        
+        # PageRank
+        try:
+            pagerank = nx.pagerank(self.graph)
+        except:
+            pagerank = {node: 1.0/self.graph.number_of_nodes() for node in self.graph.nodes()}
+        
+        # Combine centrality measures
+        for node in self.graph.nodes():
+            importance = self.graph.nodes[node].get('importance', 0.0)
+            combined_score = (
+                0.3 * degree_centrality.get(node, 0.0) +
+                0.3 * betweenness_centrality.get(node, 0.0) +
+                0.2 * pagerank.get(node, 0.0) +
+                0.2 * importance
+            )
+            centralities[node] = combined_score
+        
+        # Sort by centrality score
+        sorted_nodes = sorted(centralities.items(), key=lambda x: x[1], reverse=True)
+        return sorted_nodes[:top_k]
+    
+    def filter_graph(self, 
+                    entity_types: List[str] = None, 
+                    min_importance: float = None,
+                    relationship_types: List[str] = None) -> nx.DiGraph:
+        """Filter graph by entity types, importance, or relationship types."""
+        filtered_graph = self.graph.copy()
+        
+        # Filter nodes by type and importance
+        nodes_to_remove = []
+        for node, data in filtered_graph.nodes(data=True):
+            if entity_types and data.get('type') not in entity_types:
+                nodes_to_remove.append(node)
+            elif min_importance and data.get('importance', 0.0) < min_importance:
+                nodes_to_remove.append(node)
+        
+        filtered_graph.remove_nodes_from(nodes_to_remove)
+        
+        # Filter edges by relationship type
+        if relationship_types:
+            edges_to_remove = []
+            for u, v, data in filtered_graph.edges(data=True):
+                if data.get('relationship') not in relationship_types:
+                    edges_to_remove.append((u, v))
+            filtered_graph.remove_edges_from(edges_to_remove)
+        
+        return filtered_graph
+    
+    def export_graph(self, format_type: str = "json") -> str:
+        """Export graph in various formats."""
+        if format_type.lower() == "json":
+            return self._export_json()
+        elif format_type.lower() == "graphml":
+            return self._export_graphml()
+        elif format_type.lower() == "gexf":
+            return self._export_gexf()
+        else:
+            raise ValueError(f"Unsupported export format: {format_type}")
+    
+    def _export_json(self) -> str:
+        """Export graph as JSON."""
+        data = {
+            "nodes": [],
+            "edges": []
+        }
+        
+        # Export nodes
+        for node, attrs in self.graph.nodes(data=True):
+            node_data = {"id": node}
+            node_data.update(attrs)
+            data["nodes"].append(node_data)
+        
+        # Export edges
+        for u, v, attrs in self.graph.edges(data=True):
+            edge_data = {"source": u, "target": v}
+            edge_data.update(attrs)
+            data["edges"].append(edge_data)
+        
+        return json.dumps(data, indent=2)
+    
+    def _export_graphml(self) -> str:
+        """Export graph as GraphML."""
+        import io
+        output = io.StringIO()
+        nx.write_graphml(self.graph, output)
+        return output.getvalue()
+    
+    def _export_gexf(self) -> str:
+        """Export graph as GEXF."""
+        import io
+        output = io.StringIO()
+        nx.write_gexf(self.graph, output)
+        return output.getvalue()
+    
+    def get_subgraph_around_node(self, node: str, radius: int = 1) -> nx.DiGraph:
+        """Get subgraph within specified radius of a node."""
+        if node not in self.graph:
+            return nx.DiGraph()
+        
+        # Get nodes within radius
+        nodes_in_radius = set([node])
+        current_nodes = set([node])
+        
+        for _ in range(radius):
+            next_nodes = set()
+            for n in current_nodes:
+                # Add neighbors (both incoming and outgoing)
+                next_nodes.update(self.graph.successors(n))
+                next_nodes.update(self.graph.predecessors(n))
+            
+            nodes_in_radius.update(next_nodes)
+            current_nodes = next_nodes - nodes_in_radius
+            
+            if not current_nodes:
+                break
+        
+        return self.graph.subgraph(nodes_in_radius).copy()
+    
+    def get_shortest_path(self, source: str, target: str) -> List[str]:
+        """Get shortest path between two nodes."""
+        try:
+            # Convert to undirected for path finding
+            undirected = self.graph.to_undirected()
+            return nx.shortest_path(undirected, source, target)
+        except (nx.NetworkXNoPath, nx.NodeNotFound):
+            return []
+    
+    def get_node_info(self, node: str) -> Dict[str, Any]:
+        """Get detailed information about a specific node."""
+        if node not in self.graph:
+            return {}
+        
+        node_data = dict(self.graph.nodes[node])
+        
+        # Add connectivity information
+        predecessors = list(self.graph.predecessors(node))
+        successors = list(self.graph.successors(node))
+        
+        node_data.update({
+            "in_degree": self.graph.in_degree(node),
+            "out_degree": self.graph.out_degree(node),
+            "predecessors": predecessors,
+            "successors": successors,
+            "total_connections": len(predecessors) + len(successors)
+        })
+        
+        return node_data

src/llm_extractor.py

@@ -0,0 +1,222 @@
+import json
+import requests
+from typing import List, Dict, Any, Optional
+from config.settings import Config
+
+class LLMExtractor:
+    def __init__(self):
+        self.config = Config()
+        self.headers = {
+            "Authorization": f"Bearer {self.config.OPENROUTER_API_KEY}",
+            "Content-Type": "application/json"
+        }
+    
+    def extract_entities_and_relationships(self, text: str) -> Dict[str, Any]:
+        """Extract entities and relationships from text using LLM."""
+        prompt = self._create_extraction_prompt(text)
+        
+        try:
+            response = self._call_openrouter_api(prompt, self.config.EXTRACTION_MODEL)
+            result = self._parse_extraction_response(response)
+            return result
+        except Exception as e:
+            # Try backup model
+            try:
+                response = self._call_openrouter_api(prompt, self.config.BACKUP_MODEL)
+                result = self._parse_extraction_response(response)
+                return result
+            except Exception as backup_e:
+                return {
+                    "entities": [],
+                    "relationships": [],
+                    "error": f"Primary: {str(e)}, Backup: {str(backup_e)}"
+                }
+    
+    def _create_extraction_prompt(self, text: str) -> str:
+        """Create prompt for entity and relationship extraction."""
+        return f"""
+You are an expert knowledge graph extraction system. Analyze the following text and extract:
+
+1. ENTITIES: Important people, organizations, locations, concepts, events, objects, etc.
+2. RELATIONSHIPS: How these entities relate to each other
+3. IMPORTANCE SCORES: Rate each entity's importance from 0.0 to 1.0 based on how central it is to the text
+
+For each entity, provide:
+- name: The entity name (standardized/canonical form)
+- type: The entity type (PERSON, ORGANIZATION, LOCATION, CONCEPT, EVENT, OBJECT, etc.)
+- importance: Score from 0.0 to 1.0
+- description: Brief description of the entity's role/significance
+
+For each relationship, provide:
+- source: Source entity name
+- target: Target entity name  
+- relationship: Type of relationship (works_at, located_in, part_of, causes, etc.)
+- description: Brief description of the relationship
+
+Only respond with a valid JSON object with this structure and nothing else. Your response must be valid, parsable JSON!!
+=== JSON STRUCTURE FOR RESPONSE / RESPONSE FORMAT ===
+{{
+    "entities": [
+        {{
+            "name": "entity_name",
+            "type": "ENTITY_TYPE", 
+            "importance": 0.8,
+            "description": "Brief description"
+        }}
+    ],
+    "relationships": [
+        {{
+            "source": "entity1",
+            "target": "entity2",
+            "relationship": "relationship_type",
+            "description": "Brief description"
+        }}
+    ]
+}}
+=== END OF JSON STRUCTURE FOR RESPONSE / END OF RESPONSE FORMAT ===
+
+TEXT TO ANALYZE:
+{text}
+
+Reply in valid json using the format above!
+JSON OUTPUT:
+"""
+    
+    def _call_openrouter_api(self, prompt: str, model: str) -> str:
+        """Make API call to OpenRouter."""
+        if not self.config.OPENROUTER_API_KEY:
+            raise ValueError("OpenRouter API key not configured")
+        
+        payload = {
+            "model": model,
+            "messages": [
+                {
+                    "role": "user",
+                    "content": prompt
+                }
+            ],
+            "max_tokens": 2048,
+            "temperature": 0.1
+        }
+        
+        response = requests.post(
+            f"{self.config.OPENROUTER_BASE_URL}/chat/completions",
+            headers=self.headers,
+            json=payload,
+            timeout=60
+        )
+        
+        if response.status_code != 200:
+            raise Exception(f"API call failed: {response.status_code} - {response.text}")
+        
+        result = response.json()
+        if "choices" not in result or not result["choices"]:
+            raise Exception("Invalid API response format")
+        
+        return result["choices"][0]["message"]["content"]
+    
+    def _parse_extraction_response(self, response: str) -> Dict[str, Any]:
+        """Parse the LLM response into structured data."""
+        try:
+            # Try to find JSON in the response
+            start_idx = response.find("{")
+            end_idx = response.rfind("}") + 1
+            
+            if start_idx == -1 or end_idx == 0:
+                raise ValueError("No JSON found in response")
+            
+            json_str = response[start_idx:end_idx]
+            data = json.loads(json_str)
+            
+            # Validate structure
+            if "entities" not in data:
+                data["entities"] = []
+            if "relationships" not in data:
+                data["relationships"] = []
+            
+            # Filter entities by importance threshold
+            filtered_entities = [
+                entity for entity in data["entities"]
+                if entity.get("importance", 0) >= self.config.ENTITY_IMPORTANCE_THRESHOLD
+            ]
+            
+            # Limit number of entities and relationships
+            data["entities"] = filtered_entities[:self.config.MAX_ENTITIES]
+            data["relationships"] = data["relationships"][:self.config.MAX_RELATIONSHIPS]
+            
+            return data
+            
+        except json.JSONDecodeError as e:
+            return {
+                "entities": [],
+                "relationships": [],
+                "error": f"JSON parsing error: {str(e)}"
+            }
+        except Exception as e:
+            return {
+                "entities": [],
+                "relationships": [],
+                "error": f"Response parsing error: {str(e)}"
+            }
+    
+    def process_chunks(self, chunks: List[str]) -> Dict[str, Any]:
+        """Process multiple text chunks and combine results."""
+        all_entities = []
+        all_relationships = []
+        errors = []
+        
+        for i, chunk in enumerate(chunks):
+            try:
+                result = self.extract_entities_and_relationships(chunk)
+                
+                if "error" in result:
+                    errors.append(f"Chunk {i+1}: {result['error']}")
+                    continue
+                
+                all_entities.extend(result.get("entities", []))
+                all_relationships.extend(result.get("relationships", []))
+                
+            except Exception as e:
+                errors.append(f"Chunk {i+1}: {str(e)}")
+        
+        # Deduplicate and standardize entities
+        unique_entities = self._deduplicate_entities(all_entities)
+        
+        # Validate relationships against existing entities
+        valid_relationships = self._validate_relationships(all_relationships, unique_entities)
+        
+        return {
+            "entities": unique_entities,
+            "relationships": valid_relationships,
+            "errors": errors if errors else None
+        }
+    
+    def _deduplicate_entities(self, entities: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """Remove duplicate entities and merge similar ones."""
+        seen_names = set()
+        unique_entities = []
+        
+        for entity in entities:
+            name = entity.get("name", "").lower().strip()
+            if name and name not in seen_names:
+                seen_names.add(name)
+                unique_entities.append(entity)
+        
+        # Sort by importance
+        unique_entities.sort(key=lambda x: x.get("importance", 0), reverse=True)
+        
+        return unique_entities[:self.config.MAX_ENTITIES]
+    
+    def _validate_relationships(self, relationships: List[Dict[str, Any]], entities: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """Validate that relationships reference existing entities."""
+        entity_names = {entity.get("name", "").lower() for entity in entities}
+        valid_relationships = []
+        
+        for rel in relationships:
+            source = rel.get("source", "").lower()
+            target = rel.get("target", "").lower()
+            
+            if source in entity_names and target in entity_names:
+                valid_relationships.append(rel)
+        
+        return valid_relationships[:self.config.MAX_RELATIONSHIPS]

src/streamlit_app.py

@@ -1,40 +0,0 @@
-import altair as alt
-import numpy as np
-import pandas as pd
-import streamlit as st
-
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))

src/visualizer.py

@@ -0,0 +1,497 @@
+import matplotlib
+matplotlib.use('Agg')  # Use non-interactive backend to avoid GUI issues
+import matplotlib.pyplot as plt
+import networkx as nx
+import numpy as np
+from typing import Dict, List, Any, Tuple, Optional
+import json
+import io
+import base64
+import tempfile
+import os
+import plotly.graph_objects as go
+import plotly.express as px
+from pyvis.network import Network
+
+class GraphVisualizer:
+    def __init__(self):
+        self.color_map = {
+            'PERSON': '#FF6B6B',
+            'ORGANIZATION': '#4ECDC4', 
+            'LOCATION': '#45B7D1',
+            'CONCEPT': '#96CEB4',
+            'EVENT': '#FFEAA7',
+            'OBJECT': '#DDA0DD',
+            'UNKNOWN': '#95A5A6'
+        }
+        
+    def visualize_graph(self, 
+                       graph: nx.DiGraph, 
+                       layout_type: str = "spring",
+                       show_labels: bool = True,
+                       show_edge_labels: bool = False,
+                       node_size_factor: float = 1.0,
+                       figsize: Tuple[int, int] = (12, 8)) -> str:
+        """Create a matplotlib visualization of the graph and return file path."""
+        
+        if not graph.nodes():
+            return self._create_empty_graph_image()
+        
+        # Create figure
+        plt.figure(figsize=figsize)
+        plt.clf()
+        
+        # Calculate layout
+        pos = self._calculate_layout(graph, layout_type)
+        
+        # Get node properties
+        node_colors = [self.color_map.get(graph.nodes[node].get('type', 'UNKNOWN'), '#95A5A6') 
+                      for node in graph.nodes()]
+        node_sizes = [graph.nodes[node].get('size', 20) * node_size_factor * 10 
+                     for node in graph.nodes()]
+        
+        # Draw nodes
+        nx.draw_networkx_nodes(graph, pos, 
+                              node_color=node_colors,
+                              node_size=node_sizes,
+                              alpha=0.8)
+        
+        # Draw edges
+        nx.draw_networkx_edges(graph, pos,
+                              edge_color='gray',
+                              arrows=True,
+                              arrowsize=20,
+                              alpha=0.6,
+                              width=1.5)
+        
+        # Draw labels
+        if show_labels:
+            # Create labels with importance scores
+            labels = {}
+            for node in graph.nodes():
+                importance = graph.nodes[node].get('importance', 0.0)
+                labels[node] = f"{node}\n({importance:.2f})"
+            
+            nx.draw_networkx_labels(graph, pos, labels, font_size=8)
+        
+        # Draw edge labels
+        if show_edge_labels:
+            edge_labels = {(u, v): data.get('relationship', '') 
+                          for u, v, data in graph.edges(data=True)}
+            nx.draw_networkx_edge_labels(graph, pos, edge_labels, font_size=6)
+        
+        plt.title("Knowledge Graph", fontsize=16, fontweight='bold')
+        plt.axis('off')
+        plt.tight_layout()
+        
+        # Save to temporary file
+        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.png')
+        plt.savefig(temp_file.name, format='png', dpi=150, bbox_inches='tight')
+        plt.close()
+        
+        return temp_file.name
+    
+    def _calculate_layout(self, graph: nx.DiGraph, layout_type: str) -> Dict[str, Tuple[float, float]]:
+        """Calculate node positions using specified layout algorithm."""
+        try:
+            if layout_type == "spring":
+                return nx.spring_layout(graph, k=1, iterations=50)
+            elif layout_type == "circular":
+                return nx.circular_layout(graph)
+            elif layout_type == "shell":
+                return nx.shell_layout(graph)
+            elif layout_type == "kamada_kawai":
+                return nx.kamada_kawai_layout(graph)
+            elif layout_type == "random":
+                return nx.random_layout(graph)
+            else:
+                return nx.spring_layout(graph, k=1, iterations=50)
+        except:
+            # Fallback to simple layout if algorithm fails
+            return nx.spring_layout(graph, k=1, iterations=50)
+    
+    def _create_empty_graph_image(self) -> str:
+        """Create an image for empty graph."""
+        plt.figure(figsize=(8, 6))
+        plt.text(0.5, 0.5, 'No graph data to display', 
+                horizontalalignment='center', verticalalignment='center',
+                fontsize=16, transform=plt.gca().transAxes)
+        plt.axis('off')
+        
+        # Save to temporary file
+        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.png')
+        plt.savefig(temp_file.name, format='png', dpi=150, bbox_inches='tight')
+        plt.close()
+        
+        return temp_file.name
+    
+    def create_interactive_html(self, graph: nx.DiGraph) -> str:
+        """Create an interactive HTML visualization using vis.js."""
+        if not graph.nodes():
+            return "<div>No graph data to display</div>"
+        
+        # Convert graph to vis.js format
+        nodes = []
+        edges = []
+        
+        for node, data in graph.nodes(data=True):
+            nodes.append({
+                "id": node,
+                "label": node,
+                "color": self.color_map.get(data.get('type', 'UNKNOWN'), '#95A5A6'),
+                "size": data.get('size', 20),
+                "title": f"Type: {data.get('type', 'UNKNOWN')}<br>"
+                        f"Importance: {data.get('importance', 0.0):.2f}<br>"
+                        f"Description: {data.get('description', 'N/A')}"
+            })
+        
+        for u, v, data in graph.edges(data=True):
+            edges.append({
+                "from": u,
+                "to": v,
+                "label": data.get('relationship', ''),
+                "title": data.get('description', ''),
+                "arrows": {"to": {"enabled": True}}
+            })
+        
+        html_template = f"""
+        <!DOCTYPE html>
+        <html>
+        <head>
+            <script src="https://unpkg.com/vis-network/standalone/umd/vis-network.min.js"></script>
+            <style>
+                #mynetworkid {{
+                    width: 100%;
+                    height: 600px;
+                    border: 1px solid lightgray;
+                }}
+            </style>
+        </head>
+        <body>
+            <div id="mynetworkid"></div>
+            
+            <script>
+                var nodes = new vis.DataSet({json.dumps(nodes)});
+                var edges = new vis.DataSet({json.dumps(edges)});
+                var container = document.getElementById('mynetworkid');
+                
+                var data = {{
+                    nodes: nodes,
+                    edges: edges
+                }};
+                
+                var options = {{
+                    nodes: {{
+                        shape: 'dot',
+                        scaling: {{
+                            min: 10,
+                            max: 30
+                        }},
+                        font: {{
+                            size: 12,
+                            face: 'Tahoma'
+                        }}
+                    }},
+                    edges: {{
+                        font: {{align: 'middle'}},
+                        color: {{color:'gray'}},
+                        arrows: {{to: {{enabled: true, scaleFactor: 1}}}}
+                    }},
+                    physics: {{
+                        enabled: true,
+                        stabilization: {{enabled: true, iterations: 200}}
+                    }},
+                    interaction: {{
+                        hover: true,
+                        tooltipDelay: 200
+                    }}
+                }};
+                
+                var network = new vis.Network(container, data, options);
+            </script>
+        </body>
+        </html>
+        """
+        
+        return html_template
+    
+    def create_statistics_summary(self, graph: nx.DiGraph, stats: Dict[str, Any]) -> str:
+        """Create a formatted statistics summary."""
+        if not graph.nodes():
+            return "No graph statistics available."
+        
+        # Entity type distribution
+        type_counts = {}
+        for node, data in graph.nodes(data=True):
+            node_type = data.get('type', 'UNKNOWN')
+            type_counts[node_type] = type_counts.get(node_type, 0) + 1
+        
+        # Relationship type distribution
+        rel_counts = {}
+        for u, v, data in graph.edges(data=True):
+            rel_type = data.get('relationship', 'unknown')
+            rel_counts[rel_type] = rel_counts.get(rel_type, 0) + 1
+        
+        summary = f"""
+        ## Graph Statistics
+        
+        **Basic Metrics:**
+        - Nodes: {stats['num_nodes']}
+        - Edges: {stats['num_edges']}
+        - Density: {stats['density']:.3f}
+        - Connected: {'Yes' if stats['is_connected'] else 'No'}
+        - Components: {stats['num_components']}
+        - Average Degree: {stats['avg_degree']:.2f}
+        
+        **Entity Types:**
+        """
+        
+        for entity_type, count in sorted(type_counts.items()):
+            summary += f"\n- {entity_type}: {count}"
+        
+        summary += "\n\n**Relationship Types:**"
+        for rel_type, count in sorted(rel_counts.items()):
+            summary += f"\n- {rel_type}: {count}"
+        
+        return summary
+    
+    def create_entity_list(self, graph: nx.DiGraph, sort_by: str = "importance") -> str:
+        """Create a formatted list of entities."""
+        if not graph.nodes():
+            return "No entities found."
+        
+        entities = []
+        for node, data in graph.nodes(data=True):
+            entities.append({
+                'name': node,
+                'type': data.get('type', 'UNKNOWN'),
+                'importance': data.get('importance', 0.0),
+                'description': data.get('description', 'N/A'),
+                'connections': graph.degree(node)
+            })
+        
+        # Sort entities
+        if sort_by == "importance":
+            entities.sort(key=lambda x: x['importance'], reverse=True)
+        elif sort_by == "connections":
+            entities.sort(key=lambda x: x['connections'], reverse=True)
+        elif sort_by == "name":
+            entities.sort(key=lambda x: x['name'])
+        
+        entity_list = "## Entities\n\n"
+        for entity in entities:
+            entity_list += f"""
+**{entity['name']}** ({entity['type']})
+- Importance: {entity['importance']:.2f}
+- Connections: {entity['connections']}
+- Description: {entity['description']}
+
+"""
+        
+        return entity_list
+    
+    def get_layout_options(self) -> List[str]:
+        """Get available layout options."""
+        return ["spring", "circular", "shell", "kamada_kawai", "random"]
+    
+    def get_entity_types(self, graph: nx.DiGraph) -> List[str]:
+        """Get unique entity types from the graph."""
+        types = set()
+        for node, data in graph.nodes(data=True):
+            types.add(data.get('type', 'UNKNOWN'))
+        return sorted(list(types))
+    
+    def create_plotly_interactive(self, graph: nx.DiGraph, layout_type: str = "spring") -> go.Figure:
+        """Create an interactive Plotly visualization of the graph."""
+        if not graph.nodes():
+            # Return empty figure
+            fig = go.Figure()
+            fig.add_annotation(
+                text="No graph data to display",
+                xref="paper", yref="paper",
+                x=0.5, y=0.5, xanchor='center', yanchor='middle',
+                showarrow=False, font=dict(size=16)
+            )
+            return fig
+        
+        # Calculate layout
+        pos = self._calculate_layout(graph, layout_type)
+        
+        # Prepare node data
+        node_x = []
+        node_y = []
+        node_text = []
+        node_info = []
+        node_colors = []
+        node_sizes = []
+        
+        for node in graph.nodes():
+            x, y = pos[node]
+            node_x.append(x)
+            node_y.append(y)
+            
+            data = graph.nodes[node]
+            node_type = data.get('type', 'UNKNOWN')
+            importance = data.get('importance', 0.0)
+            description = data.get('description', 'N/A')
+            connections = graph.degree(node)
+            
+            node_text.append(node)
+            node_info.append(
+                f"<b>{node}</b><br>"
+                f"Type: {node_type}<br>"
+                f"Importance: {importance:.2f}<br>"
+                f"Connections: {connections}<br>"
+                f"Description: {description}"
+            )
+            node_colors.append(self.color_map.get(node_type, '#95A5A6'))
+            node_sizes.append(max(10, data.get('size', 20)))
+        
+        # Prepare edge data
+        edge_x = []
+        edge_y = []
+        edge_info = []
+        
+        for edge in graph.edges():
+            x0, y0 = pos[edge[0]]
+            x1, y1 = pos[edge[1]]
+            edge_x.extend([x0, x1, None])
+            edge_y.extend([y0, y1, None])
+            
+            edge_data = graph.edges[edge]
+            relationship = edge_data.get('relationship', 'connected')
+            edge_info.append(f"{edge[0]} → {edge[1]}<br>Relationship: {relationship}")
+        
+        # Create edge trace
+        edge_trace = go.Scatter(
+            x=edge_x, y=edge_y,
+            line=dict(width=2, color='gray'),
+            hoverinfo='none',
+            mode='lines'
+        )
+        
+        # Create node trace
+        node_trace = go.Scatter(
+            x=node_x, y=node_y,
+            mode='markers+text',
+            hoverinfo='text',
+            text=node_text,
+            hovertext=node_info,
+            textposition="middle center",
+            marker=dict(
+                size=node_sizes,
+                color=node_colors,
+                line=dict(width=2, color='white')
+            )
+        )
+        
+        # Create figure
+        fig = go.Figure(data=[edge_trace, node_trace],
+                       layout=go.Layout(
+                           title='Interactive Knowledge Graph',
+                           titlefont_size=16,
+                           showlegend=False,
+                           hovermode='closest',
+                           margin=dict(b=20,l=5,r=5,t=40),
+                           annotations=[ dict(
+                               text="Hover over nodes for details. Drag to pan, scroll to zoom.",
+                               showarrow=False,
+                               xref="paper", yref="paper",
+                               x=0.005, y=-0.002,
+                               xanchor='left', yanchor='bottom',
+                               font=dict(color="gray", size=12)
+                           )],
+                           xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+                           yaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+                           plot_bgcolor='white'
+                       ))
+        
+        return fig
+    
+    def create_pyvis_interactive(self, graph: nx.DiGraph, layout_type: str = "spring") -> str:
+        """Create an interactive pyvis visualization and return HTML file path."""
+        if not graph.nodes():
+            return self._create_empty_pyvis_graph()
+        
+        # Create pyvis network
+        net = Network(height="600px", width="100%", bgcolor="#ffffff", font_color="black")
+        
+        # Configure physics
+        net.set_options("""
+        {
+          "physics": {
+            "enabled": true,
+            "stabilization": {"enabled": true, "iterations": 200},
+            "barnesHut": {
+              "gravitationalConstant": -2000,
+              "centralGravity": 0.3,
+              "springLength": 95,
+              "springConstant": 0.04,
+              "damping": 0.09
+            }
+          },
+          "interaction": {
+            "hover": true,
+            "tooltipDelay": 200,
+            "hideEdgesOnDrag": false
+          }
+        }
+        """)
+        
+        # Add nodes
+        for node, data in graph.nodes(data=True):
+            node_type = data.get('type', 'UNKNOWN')
+            importance = data.get('importance', 0.0)
+            description = data.get('description', 'N/A')
+            connections = graph.degree(node)
+            
+            # Node properties
+            color = self.color_map.get(node_type, '#95A5A6')
+            size = max(10, data.get('size', 20))
+            
+            # Tooltip text
+            title = f"""
+            <b>{node}</b><br>
+            Type: {node_type}<br>
+            Importance: {importance:.2f}<br>
+            Connections: {connections}<br>
+            Description: {description}
+            """
+            
+            net.add_node(node, label=node, title=title, color=color, size=size)
+        
+        # Add edges
+        for u, v, data in graph.edges(data=True):
+            relationship = data.get('relationship', 'connected')
+            title = f"{u} → {v}<br>Relationship: {relationship}"
+            
+            net.add_edge(u, v, title=title, arrows="to", color="gray")
+        
+        # Save to temporary file
+        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.html', mode='w')
+        net.save_graph(temp_file.name)
+        temp_file.close()
+        
+        return temp_file.name
+    
+    def _create_empty_pyvis_graph(self) -> str:
+        """Create an empty pyvis graph."""
+        net = Network(height="600px", width="100%", bgcolor="#ffffff", font_color="black")
+        net.add_node(1, label="No graph data", color="#cccccc")
+        
+        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.html', mode='w')
+        net.save_graph(temp_file.name)
+        temp_file.close()
+        
+        return temp_file.name
+    
+    def get_visualization_options(self) -> List[str]:
+        """Get available visualization types."""
+        return ["matplotlib", "plotly", "pyvis", "vis.js"]
+    
+    def get_relationship_types(self, graph: nx.DiGraph) -> List[str]:
+        """Get unique relationship types from the graph."""
+        types = set()
+        for u, v, data in graph.edges(data=True):
+            types.add(data.get('relationship', 'unknown'))
+        return sorted(list(types))

test_document.txt

@@ -0,0 +1,15 @@
+Knowledge Graph Test Document
+
+This is a test document for the knowledge graph extraction application. The document discusses several important entities and their relationships.
+
+John Smith is a software engineer at TechCorp, a technology company located in San Francisco. He works on artificial intelligence projects and collaborates with Sarah Johnson, who is the head of research at the same company.
+
+TechCorp was founded in 2015 and specializes in machine learning solutions. The company has partnerships with several universities, including Stanford University and MIT, for collaborative research on natural language processing.
+
+The artificial intelligence field has seen rapid advancement in recent years, particularly in areas like deep learning and neural networks. These technologies are revolutionizing industries such as healthcare, finance, and autonomous vehicles.
+
+Sarah Johnson previously worked at DataSystems Inc, another technology company, before joining TechCorp in 2018. She holds a PhD in Computer Science from Stanford University and has published numerous papers on machine learning algorithms.
+
+The collaboration between TechCorp and Stanford University has resulted in several breakthrough innovations in conversational AI and knowledge representation systems. These projects are funded by government grants and private investments.
+
+Machine learning and artificial intelligence are closely related concepts that form the foundation of modern data science and automation technologies.