Add Baseline + Graph RAG tools

.python-version

@@ -1 +1 @@
-3.10
+3.13

experiments/csv-lib/main.py

@@ -0,0 +1,21 @@
+import csv
+import argparse
+
+parser = argparse.ArgumentParser(
+    description="Convert a text file to a CSV file with one line per row."
+)
+parser.add_argument("--txt", required=True, help="Path to the input text file.")
+parser.add_argument("--csv", required=True, help="Path to the output CSV file.")
+args = parser.parse_args()
+
+txt_file_path = args.txt
+csv_file_path = args.csv
+with (
+    open(txt_file_path, "r", encoding="utf-8") as txt_file,
+    open(csv_file_path, "w", encoding="utf-8") as csv_file,
+):
+    fieldnames = ["id", "prompt"]
+    writer = csv.DictWriter(csv_file, fieldnames=fieldnames)
+    writer.writeheader()
+    for i, line in enumerate(txt_file):
+        writer.writerow({"id": i, "prompt": line.rstrip("\n")})

experiments/entity-graph/.gitignore

@@ -0,0 +1,3 @@
+files/
+*.json
+*.html

experiments/entity-graph/config.toml

@@ -0,0 +1,19 @@
+[llm]
+model = "llama3.2"
+api_key = ""
+base_url = "http://localhost:11434/v1/chat/completions" # Local Ollama instance running locally (but can be any OpenAI compatible endpoint)
+max_tokens = 8192
+temperature = 0.2
+
+[chunking]
+chunk_size = 200  # Number of words per chunk
+overlap = 20      # Number of words to overlap between chunks
+
+[standardization]
+enabled = true            # Enable entity standardization
+use_llm_for_entities = true  # Use LLM for additional entity resolution
+
+[inference]
+enabled = true             # Enable relationship inference
+use_llm_for_inference = true  # Use LLM for relationship inference
+apply_transitive = true    # Apply transitive inference rules

experiments/entity-graph/pyproject.toml

@@ -0,0 +1,12 @@
+[project]
+name = "entity-graph"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "ai-knowledge-graph",
+]
+
+[tool.uv.sources]
+ai-knowledge-graph = { git = "https://github.com/robert-mcdermott/ai-knowledge-graph.git" }

experiments/lightrag/.gitignore

@@ -0,0 +1,3 @@
+rag_storage/
+example_storage/
+lightrag_storage/

experiments/lightrag/README.md

@@ -0,0 +1,163 @@
+# LightRAG Memgraph Integration
+
+A Python library that integrates LightRAG with Memgraph for knowledge graph-based Retrieval-Augmented Generation (RAG).
+
+## Features
+
+- **Knowledge Graph Storage**: Uses Memgraph as the graph storage backend for LightRAG
+- **Multiple Search Modes**: Supports both naive and hybrid search strategies
+- **Async Support**: Fully asynchronous API for better performance
+- **Easy Integration**: Simple interface for text insertion and querying
+
+## Installation
+
+This library requires Python 3.8 or higher and uses uv for dependency management.
+
+```bash
+# Install the library
+uv add lightrag-memgraph
+
+# Or install in development mode
+uv pip install -e .
+```
+
+## Dependencies
+
+- `lightrag-hku[api]` - Core LightRAG functionality
+- `openai` - OpenAI API integration for embeddings and LLM
+
+## Usage
+
+### Basic Setup
+
+```python
+import asyncio
+from lightrag_memgraph import initialize_lightrag_memgraph
+
+async def main():
+    # Initialize LightRAG with Memgraph storage
+    rag = await initialize_lightrag_memgraph(working_dir="./my_rag_storage")
+
+    # Insert some text
+    await rag.insert_text("Your document content here...")
+
+    # Query the knowledge graph
+    result = await rag.query_hybrid("What is this document about?")
+    print(result)
+
+asyncio.run(main())
+```
+
+### Using the Class Directly
+
+```python
+import asyncio
+from lightrag_memgraph import LightRAGMemgraph
+
+async def main():
+    # Create instance
+    rag = LightRAGMemgraph(working_dir="./my_rag_storage", log_level="INFO")
+
+    # Initialize
+    await rag.initialize()
+
+    # Insert text
+    await rag.insert_text("Document content...")
+
+    # Search
+    naive_result = await rag.query_naive("Simple query")
+    hybrid_result = await rag.query_hybrid("Complex query")
+
+    print(f"Naive: {naive_result}")
+    print(f"Hybrid: {hybrid_result}")
+
+asyncio.run(main())
+```
+
+### Using Convenience Functions
+
+```python
+import asyncio
+from lightrag_memgraph import initialize_lightrag_memgraph, naive_search, hybrid_search, insert_text
+
+async def main():
+    rag = await initialize_lightrag_memgraph()
+
+    # Insert text
+    await insert_text(rag, "Your content here...")
+
+    # Search using convenience functions
+    result1 = await naive_search(rag, "Query 1")
+    result2 = await hybrid_search(rag, "Query 2")
+
+asyncio.run(main())
+```
+
+## Configuration
+
+### Environment Variables
+
+Make sure to set your OpenAI API key and Memgraph connection details:
+
+```bash
+export OPENAI_API_KEY="your-api-key-here"
+export MEMGRAPH_URI="bolt://localhost:7687"
+```
+
+### Memgraph Configuration
+
+The library uses Memgraph as the graph storage backend. Ensure you have a Memgraph instance running and accessible. The connection details are configured through environment variables:
+
+- `MEMGRAPH_URI`: Memgraph connection URI (default: `bolt://localhost:7687`)
+- `MEMGRAPH_USER`: Memgraph username (optional)
+- `MEMGRAPH_PASSWORD`: Memgraph password (optional)
+
+## Development
+
+### Setup Development Environment
+
+```bash
+# Install development dependencies
+uv pip install -e ".[dev]"
+
+# Run tests
+pytest
+
+# Format code
+black src/
+isort src/
+
+# Type checking
+mypy src/
+```
+
+## API Reference
+
+### LightRAGMemgraph
+
+Main class for LightRAG with Memgraph integration.
+
+#### Methods
+
+- `__init__(working_dir: str, log_level: str)`: Initialize the instance
+- `initialize()`: Initialize LightRAG with Memgraph storage
+- `query_naive(query: str)`: Perform naive search
+- `query_hybrid(query: str)`: Perform hybrid search  
+- `insert_text(text: str)`: Insert text into the knowledge graph
+
+### Convenience Functions
+
+- `initialize_lightrag_memgraph(working_dir: str)`: Initialize and return a ready-to-use instance
+- `naive_search(rag, query: str)`: Perform naive search
+- `hybrid_search(rag, query: str)`: Perform hybrid search
+- `insert_text(rag, text: str)`: Insert text
+
+## Notes
+
+- This is an experimental integration and may have limitations
+- MemgraphStorage configuration may need to be adjusted based on your Memgraph setup
+- Both `initialize_storages()` and `initialize_pipeline_status()` are called automatically during initialization
+
+## License
+
+This project is part of the Memgraph AI Toolkit.

experiments/lightrag/main.py

@@ -0,0 +1,22 @@
+#!/usr/bin/env python3
+"""Example usage of LightRAG Memgraph integration."""
+
+import asyncio
+from lightrag_memgraph import initialize_lightrag_memgraph
+
+
+async def main():
+    """Example main function demonstrating LightRAG Memgraph usage."""
+    print("Memgraph LightRAG Wrapper")
+
+    # Initialize LightRAG with Memgraph storage
+    rag = await initialize_lightrag_memgraph(working_dir="./lightrag_storage")
+
+    # Example usage (uncomment to test):
+    await rag.insert_text("This is a sample document about artificial intelligence.")
+    result = await rag.query_hybrid("What is this document about?")
+    print(f"Query result: {result}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

experiments/lightrag/pyproject.toml

@@ -0,0 +1,50 @@
+[project]
+name = "lightrag-memgraph"
+version = "0.1.18"
+description = "LightRAG integration with Memgraph for knowledge graph-based RAG"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    # "lightrag-hku[api] @ file:///home/buda/Workspace/tmp/LightRAG",
+    "lightrag-hku[api]>=0.0.1",
+    "openai>=1.0.0",
+    "neo4j>=5.0.0",
+    "accelerate>=1.10.1",
+    "torch>=2.8.0",
+    "transformers<=4.48.3",
+    # "flash-attn>=2.8.3", # NOTE: It causes a lot of issue because explicit torch deps requried.
+    # "bitsandbytes>=0.47.0", # NOTE: Doesn't work on Mac
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-asyncio>=0.21.0",
+    "black>=23.0.0",
+    "isort>=5.12.0",
+    "mypy>=1.0.0",
+]
+
+[tool.uv.extra-build-dependencies]
+flash-attn = ["torch"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/lightrag_memgraph"]
+
+[tool.black]
+line-length = 88
+target-version = ['py310']
+
+[tool.isort]
+profile = "black"
+line_length = 88
+
+[tool.mypy]
+python_version = "3.10"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = true

experiments/lightrag/src/lightrag_memgraph/__init__.py

@@ -0,0 +1,14 @@
+"""LightRAG integration with Memgraph for knowledge graph-based RAG."""
+
+from .core import LightRAGMemgraph, initialize_lightrag_memgraph
+from .search import naive_search, hybrid_search
+from .insert import insert_text
+
+__version__ = "0.1.0"
+__all__ = [
+    "LightRAGMemgraph",
+    "initialize_lightrag_memgraph",
+    "naive_search",
+    "hybrid_search",
+    "insert_text",
+]