graphcontainer 0.1.0__tar.gz

graphcontainer-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Seonho AN and Chaejeong HYUN
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

graphcontainer-0.1.0/PKG-INFO

@@ -0,0 +1,182 @@
+Metadata-Version: 2.4
+Name: graphcontainer
+Version: 0.1.0
+Summary: Unified workflow for working with graph RAG systems
+Author: asmath472
+License: MIT License
+        
+        Copyright (c) 2026 Seonho AN and Chaejeong HYUN
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: chromadb>=1.4.1
+Requires-Dist: flagembedding>=1.3.5
+Requires-Dist: openai>=1.108.1
+Requires-Dist: pandas>=3.0.0
+Requires-Dist: python-dotenv>=1.2.1
+Requires-Dist: pyct>=0.6.0
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: pyvis>=0.3.2
+Requires-Dist: sentence-transformers>=5.2.0
+Requires-Dist: tiktoken>=0.12.0
+Requires-Dist: torch>=2.10.0
+Requires-Dist: tqdm>=4.67.1
+Requires-Dist: transformers>=4.57.6
+Requires-Dist: ollama>=0.6.1
+Dynamic: license-file
+
+## GraphContainer
+
+<p align="center">
+  <img src="graph-container-workflow.jpg" alt="GraphContainer workflow" width="760">
+</p>
+
+**GraphContainer** provides a unified workflow for working with graph RAG systems. It is designed to load graphs produced by different methods, convert them into a shared internal representation, run retrieval pipelines on top of that representation, visualize retrieval traces in a browser, and execute experiments through a consistent interface.
+
+[![YouTube Demo](https://img.shields.io/badge/YouTube-Demo-red?style=for-the-badge&logo=youtube&logoColor=white)](https://youtu.be/O02eNJLwkU0)
+
+### Overview
+
+The main idea behind GraphContainer is simple: different graph RAG methods store graph data in different formats, but once those graphs are converted into a common structure, they can be searched, visualized, and compared in a much more consistent way. In this repository, that common structure is implemented through the Unified Graph State, which stores nodes, edges, adjacency information, and vector indexes in a form that downstream components can access without caring about the original source format.
+
+At the core of the implementation are `SimpleGraphContainer` and `SearchableGraphContainer`. `SimpleGraphContainer` is responsible for holding the in-memory graph itself, while `SearchableGraphContainer` extends that base structure with pluggable vector indexes such as `node_vector`. On top of this container layer, the repository provides adapters for different upstream graph formats, including `import_graph_from_component_graph` (Component Graph), `import_graph_from_attribute_bundle_graph` (Attribute Bundle Graph), `import_graph_from_topology_semantic_graph` (Topology-Semantic Graph), and `import_graph_from_subgraph_union_graph` (Subgraph Union Graph). These adapters are the entry points that translate method-specific graph storage into the unified internal graph state used by the rest of the system.
+
+Once a graph has been loaded, retrieval is handled by the RAG modules under `src/graphcontainer/rag`. The embedding path is managed through `src/graphcontainer/rag/embeddings.py`, and the retrieval logic lives in `src/graphcontainer/rag/retrievers.py`. The repository currently includes two retrieval strategies: `OneHopRetriever`, which starts from vector-retrieved seed nodes and expands to their immediate neighbors, and `FastInsightRetriever`, which applies a multi-stage retrieval process with seed selection, deeper exploration, and final filtering. In the current experiment setup, the initial retrieval size is set to `10`, and FastInsight keeps the final `5` nodes before answer generation.
+
+The end-to-end experiment pipeline is implemented in [test/rag_experiment.py](/./test/rag_experiment.py). This script loads the available graphs, applies the retrievers, builds prompts from the retrieved content, sends the prompts to the generator model, and writes the outputs as JSONL files. In other words, the implementation path is: load a graph from a method-specific source, convert it into the unified graph container, run retrieval on top of the shared representation, assemble the retrieved evidence into a prompt, generate an answer, and finally save the result for evaluation.
+
+### Installation
+
+Before running the project, make sure `uv` itself is installed. On macOS and Linux, you can install it with the official standalone installer:
+
+```bash
+curl -LsSf https://astral.sh/uv/install.sh | sh
+```
+
+On Windows PowerShell, you can install it with:
+
+```powershell
+powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
+```
+
+If you prefer another installation method, such as Homebrew, WinGet, Scoop, or `pipx`, you can use the official `uv` installation guide.
+
+If you want to install the published package from PyPI, use:
+
+```bash
+pip install graphcontainer
+```
+
+If you are developing locally from this repository, install the project dependencies with:
+
+```bash
+uv sync
+```
+
+After installation, restart bash and use the command below to activate the virtual environment.
+
+```bash
+source .venv/bin/activate
+```
+
+Also, you can get example graphs in the below Google Drive link. Place this on the project root directory.
+
+[![Google Drive Graph Data](https://img.shields.io/badge/Google%20Drive-Graph_Data-blue?style=for-the-badge&logo=googledrive&logoColor=white)](https://drive.google.com/file/d/1pK8mK2Jgp3T4gVUOuHQrVz2xSpDBIGdV/view?usp=sharing)
+
+<!-- [Google Drive link](https://drive.google.com/file/d/1pK8mK2Jgp3T4gVUOuHQrVz2xSpDBIGdV/view?usp=sharing). Place this on the project root directory. -->
+
+### Web-based Visualizer
+
+The web interface is powered by the live visualizer. You can launch it directly from the command line by pointing it to a graph source:
+
+<!-- ```bash
+uv run python -m graphcontainer.visualizer.live_visualizer \
+  --source data/rag_storage/fastinsight/scifact-openai \
+  --host 127.0.0.1 \
+  --port 8765 \
+  --hops 2
+``` -->
+
+```bash
+python serve.py --graph component_graph:./data/rag_storage/fastinsight/scifact-openai \
+  --host 127.0.0.1 \
+  --port 8765 \
+  --hops 2
+```
+
+
+After the server starts, open `http://127.0.0.1:8765` in your browser. The page renders the graph or subgraph associated with the current retrieval session and lets you inspect how the retriever moved through the graph. Nodes and edges selected during retrieval can be highlighted, and the visualizer keeps track of session progress so that a query can be inspected step by step instead of only as a final result.
+
+If you already have a graph object in memory, you can launch the same interface from Python by using `serve_graph`:
+
+```python
+from graphcontainer import serve_graph
+
+visualizer = serve_graph(
+    graph,
+    host="127.0.0.1",
+    port=8765,
+    default_hops=2,
+)
+
+print(visualizer.url)
+```
+
+If your graph is stored in Component Graph format, you can also serve it directly from storage:
+
+```python
+from graphcontainer import serve_component_graph
+
+visualizer = serve_component_graph(
+    "data/rag_storage/fastinsight/scifact-openai",
+    host="127.0.0.1",
+    port=8765,
+    default_hops=2,
+)
+```
+
+In practice, the web page is useful for understanding what happened during retrieval rather than only checking the final answer. A typical flow is to start the visualizer, open the browser page, submit a query or connect to an existing retrieval session, and then inspect the highlighted nodes, edges, and progress updates. This makes it easier to see which evidence was selected, how graph traversal expanded from the initial seeds, and how the retrieved subgraph contributed to the final answer.
+
+### Run Experiments
+
+The default experiment path in this repository is provided through [scripts/run_batch_experiment.sh](./scripts/run_batch_experiment.sh). This script is intentionally fixed to the current experimental setup and can be run with:
+
+```bash
+uv run bash scripts/run_batch_experiment.sh
+```
+
+By default, this runs the experiment on the `bsard` dataset with `query_limit=-1`, `top_k=10`, `index_name=node_vector`, `ollama_url=http://localhost:11434/v1`, `ollama_model=gemma3:12b`, and `max_context_chunks=10`. The current setup uses `text-embedding-3-small` for embeddings, and the experiment script iterates over the available graph imports while applying both retrieval methods to each graph.
+
+If you want to run the experiment entry point directly rather than going through the batch script, you can execute:
+
+```bash
+uv run python test/rag_experiment.py \
+  --dataset bsard \
+  --query_limit -1 \
+  --top_k 10 \
+  --index_name node_vector \
+  --output_dir ./output/bsard \
+  --ollama_url http://localhost:11434/v1 \
+  --ollama_model gemma3:12b \
+  --max_context_chunks 10
+```
+
+The outputs are saved as JSONL files under `./output/bsard/`, typically in files named like `<graph_name>_<retriever>.jsonl`. Each line contains a single query-output pair in the form `{"query": "question text", "output": "generated answer"}`. This makes the results easy to evaluate later with a separate judging or comparison pipeline.

graphcontainer-0.1.0/README.md

@@ -0,0 +1,137 @@
+## GraphContainer
+
+<p align="center">
+  <img src="graph-container-workflow.jpg" alt="GraphContainer workflow" width="760">
+</p>
+
+**GraphContainer** provides a unified workflow for working with graph RAG systems. It is designed to load graphs produced by different methods, convert them into a shared internal representation, run retrieval pipelines on top of that representation, visualize retrieval traces in a browser, and execute experiments through a consistent interface.
+
+[![YouTube Demo](https://img.shields.io/badge/YouTube-Demo-red?style=for-the-badge&logo=youtube&logoColor=white)](https://youtu.be/O02eNJLwkU0)
+
+### Overview
+
+The main idea behind GraphContainer is simple: different graph RAG methods store graph data in different formats, but once those graphs are converted into a common structure, they can be searched, visualized, and compared in a much more consistent way. In this repository, that common structure is implemented through the Unified Graph State, which stores nodes, edges, adjacency information, and vector indexes in a form that downstream components can access without caring about the original source format.
+
+At the core of the implementation are `SimpleGraphContainer` and `SearchableGraphContainer`. `SimpleGraphContainer` is responsible for holding the in-memory graph itself, while `SearchableGraphContainer` extends that base structure with pluggable vector indexes such as `node_vector`. On top of this container layer, the repository provides adapters for different upstream graph formats, including `import_graph_from_component_graph` (Component Graph), `import_graph_from_attribute_bundle_graph` (Attribute Bundle Graph), `import_graph_from_topology_semantic_graph` (Topology-Semantic Graph), and `import_graph_from_subgraph_union_graph` (Subgraph Union Graph). These adapters are the entry points that translate method-specific graph storage into the unified internal graph state used by the rest of the system.
+
+Once a graph has been loaded, retrieval is handled by the RAG modules under `src/graphcontainer/rag`. The embedding path is managed through `src/graphcontainer/rag/embeddings.py`, and the retrieval logic lives in `src/graphcontainer/rag/retrievers.py`. The repository currently includes two retrieval strategies: `OneHopRetriever`, which starts from vector-retrieved seed nodes and expands to their immediate neighbors, and `FastInsightRetriever`, which applies a multi-stage retrieval process with seed selection, deeper exploration, and final filtering. In the current experiment setup, the initial retrieval size is set to `10`, and FastInsight keeps the final `5` nodes before answer generation.
+
+The end-to-end experiment pipeline is implemented in [test/rag_experiment.py](/./test/rag_experiment.py). This script loads the available graphs, applies the retrievers, builds prompts from the retrieved content, sends the prompts to the generator model, and writes the outputs as JSONL files. In other words, the implementation path is: load a graph from a method-specific source, convert it into the unified graph container, run retrieval on top of the shared representation, assemble the retrieved evidence into a prompt, generate an answer, and finally save the result for evaluation.
+
+### Installation
+
+Before running the project, make sure `uv` itself is installed. On macOS and Linux, you can install it with the official standalone installer:
+
+```bash
+curl -LsSf https://astral.sh/uv/install.sh | sh
+```
+
+On Windows PowerShell, you can install it with:
+
+```powershell
+powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
+```
+
+If you prefer another installation method, such as Homebrew, WinGet, Scoop, or `pipx`, you can use the official `uv` installation guide.
+
+If you want to install the published package from PyPI, use:
+
+```bash
+pip install graphcontainer
+```
+
+If you are developing locally from this repository, install the project dependencies with:
+
+```bash
+uv sync
+```
+
+After installation, restart bash and use the command below to activate the virtual environment.
+
+```bash
+source .venv/bin/activate
+```
+
+Also, you can get example graphs in the below Google Drive link. Place this on the project root directory.
+
+[![Google Drive Graph Data](https://img.shields.io/badge/Google%20Drive-Graph_Data-blue?style=for-the-badge&logo=googledrive&logoColor=white)](https://drive.google.com/file/d/1pK8mK2Jgp3T4gVUOuHQrVz2xSpDBIGdV/view?usp=sharing)
+
+<!-- [Google Drive link](https://drive.google.com/file/d/1pK8mK2Jgp3T4gVUOuHQrVz2xSpDBIGdV/view?usp=sharing). Place this on the project root directory. -->
+
+### Web-based Visualizer
+
+The web interface is powered by the live visualizer. You can launch it directly from the command line by pointing it to a graph source:
+
+<!-- ```bash
+uv run python -m graphcontainer.visualizer.live_visualizer \
+  --source data/rag_storage/fastinsight/scifact-openai \
+  --host 127.0.0.1 \
+  --port 8765 \
+  --hops 2
+``` -->
+
+```bash
+python serve.py --graph component_graph:./data/rag_storage/fastinsight/scifact-openai \
+  --host 127.0.0.1 \
+  --port 8765 \
+  --hops 2
+```
+
+
+After the server starts, open `http://127.0.0.1:8765` in your browser. The page renders the graph or subgraph associated with the current retrieval session and lets you inspect how the retriever moved through the graph. Nodes and edges selected during retrieval can be highlighted, and the visualizer keeps track of session progress so that a query can be inspected step by step instead of only as a final result.
+
+If you already have a graph object in memory, you can launch the same interface from Python by using `serve_graph`:
+
+```python
+from graphcontainer import serve_graph
+
+visualizer = serve_graph(
+    graph,
+    host="127.0.0.1",
+    port=8765,
+    default_hops=2,
+)
+
+print(visualizer.url)
+```
+
+If your graph is stored in Component Graph format, you can also serve it directly from storage:
+
+```python
+from graphcontainer import serve_component_graph
+
+visualizer = serve_component_graph(
+    "data/rag_storage/fastinsight/scifact-openai",
+    host="127.0.0.1",
+    port=8765,
+    default_hops=2,
+)
+```
+
+In practice, the web page is useful for understanding what happened during retrieval rather than only checking the final answer. A typical flow is to start the visualizer, open the browser page, submit a query or connect to an existing retrieval session, and then inspect the highlighted nodes, edges, and progress updates. This makes it easier to see which evidence was selected, how graph traversal expanded from the initial seeds, and how the retrieved subgraph contributed to the final answer.
+
+### Run Experiments
+
+The default experiment path in this repository is provided through [scripts/run_batch_experiment.sh](./scripts/run_batch_experiment.sh). This script is intentionally fixed to the current experimental setup and can be run with:
+
+```bash
+uv run bash scripts/run_batch_experiment.sh
+```
+
+By default, this runs the experiment on the `bsard` dataset with `query_limit=-1`, `top_k=10`, `index_name=node_vector`, `ollama_url=http://localhost:11434/v1`, `ollama_model=gemma3:12b`, and `max_context_chunks=10`. The current setup uses `text-embedding-3-small` for embeddings, and the experiment script iterates over the available graph imports while applying both retrieval methods to each graph.
+
+If you want to run the experiment entry point directly rather than going through the batch script, you can execute:
+
+```bash
+uv run python test/rag_experiment.py \
+  --dataset bsard \
+  --query_limit -1 \
+  --top_k 10 \
+  --index_name node_vector \
+  --output_dir ./output/bsard \
+  --ollama_url http://localhost:11434/v1 \
+  --ollama_model gemma3:12b \
+  --max_context_chunks 10
+```
+
+The outputs are saved as JSONL files under `./output/bsard/`, typically in files named like `<graph_name>_<retriever>.jsonl`. Each line contains a single query-output pair in the form `{"query": "question text", "output": "generated answer"}`. This makes the results easy to evaluate later with a separate judging or comparison pipeline.

graphcontainer-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "graphcontainer"
+version = "0.1.0"
+description = "Unified workflow for working with graph RAG systems"
+readme = "README.md"
+requires-python = ">=3.11"
+license = { file = "LICENSE" }
+authors = [
+    { name = "asmath472" },
+]
+dependencies = [
+    "chromadb>=1.4.1",
+    "flagembedding>=1.3.5",
+    "openai>=1.108.1",
+    "pandas>=3.0.0",
+    "python-dotenv>=1.2.1",
+    "pyct>=0.6.0",
+    "pydantic>=2.12.5",
+    "pyvis>=0.3.2",
+    "sentence-transformers>=5.2.0",
+    "tiktoken>=0.12.0",
+    "torch>=2.10.0",
+    "tqdm>=4.67.1",
+    "transformers>=4.57.6",
+    "ollama>=0.6.1",
+]
+
+[tool.setuptools]
+include-package-data = true
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["graphcontainer*"]
+exclude = ["test*"]
+
+[tool.setuptools.package-data]
+graphcontainer = ["visualizer/web/*"]

graphcontainer-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

graphcontainer-0.1.0/setup.py

@@ -0,0 +1,4 @@
+from setuptools import setup
+
+
+setup()

graphcontainer-0.1.0/src/graphcontainer/__init__.py

@@ -0,0 +1,123 @@
+from .base import BaseGraphContainer
+from .core import SearchableGraphContainer, SimpleGraphContainer
+from .index import BaseIndexer
+from .indexers import ChromaCollectionIndexer, InMemoryVectorIndexer, PGVectorIndexer
+from .types import EdgeRecord, NodeRecord
+from .adapters import (
+    FastInsightAdapter,
+    GraphAdapter,
+    GraphAdapterError,
+    LightRAGAdapter,
+    UnsupportedSourceError,
+    import_graph_from_attribute_bundle_graph,
+    import_graph_from_component_graph,
+    import_graph_from_fastinsight,
+    import_graph_from_lightrag,
+    import_graph_from_subgraph_union_graph,
+    import_graph_from_topology_semantic_graph,
+)
+from .visualizer import (
+    LiveGraphVisualizer,
+    LiveVisualizerClient,
+    VisualizerHTTPError,
+    clear_session,
+    create_session,
+    delete_session,
+    get_config,
+    get_session_snapshot,
+    get_session_subgraph,
+    health,
+    list_sessions,
+    set_progress,
+    serve_attribute_bundle_graph,
+    serve_component_graph,
+    serve_fastinsight,
+    serve_g_retriever,
+    serve_graph,
+    serve_hipporag,
+    serve_lightrag,
+    serve_multi,
+    serve_subgraph_union_graph,
+    serve_topology_semantic_graph,
+    serve_tog,
+    update_session,
+)
+from .rag import (
+    BaseRetriever,
+    ChatMessage,
+    ChatRequest,
+    ChatResponse,
+    GraphRAGPipeline,
+    GraphRAGService,
+    FastInsightRetriever,
+    HybridRetriever,
+    OneHopRetriever,
+    OpenAIChatGenerator,
+    OpenAIEmbedder,
+    RetrievedNode,
+    RetrievalResult,
+    VectorRetriever,
+)
+
+__all__ = [
+    "BaseGraphContainer",
+    "SearchableGraphContainer",
+    "SimpleGraphContainer",
+    "BaseIndexer",
+    "EdgeRecord",
+    "NodeRecord",
+    "GraphAdapter",
+    "GraphAdapterError",
+    "UnsupportedSourceError",
+    "FastInsightAdapter",
+    "LightRAGAdapter",
+    "InMemoryVectorIndexer",
+    "ChromaCollectionIndexer",
+    "PGVectorIndexer",
+    "import_graph_from_component_graph",
+    "import_graph_from_attribute_bundle_graph",
+    "import_graph_from_topology_semantic_graph",
+    "import_graph_from_subgraph_union_graph",
+    "import_graph_from_fastinsight",
+    "import_graph_from_lightrag",
+    "render_graph_html",
+    "render_fastinsight_html",
+    "LiveGraphVisualizer",
+    "serve_graph",
+    "serve_component_graph",
+    "serve_attribute_bundle_graph",
+    "serve_topology_semantic_graph",
+    "serve_subgraph_union_graph",
+    "serve_fastinsight",
+    "serve_lightrag",
+    "serve_hipporag",
+    "serve_g_retriever",
+    "serve_tog",
+    "serve_multi",
+    "VisualizerHTTPError",
+    "LiveVisualizerClient",
+    "health",
+    "get_config",
+    "list_sessions",
+    "create_session",
+    "get_session_snapshot",
+    "get_session_subgraph",
+    "update_session",
+    "set_progress",
+    "clear_session",
+    "delete_session",
+    "ChatMessage",
+    "ChatRequest",
+    "ChatResponse",
+    "RetrievedNode",
+    "RetrievalResult",
+    "OpenAIEmbedder",
+    "OpenAIChatGenerator",
+    "BaseRetriever",
+    "OneHopRetriever",
+    "VectorRetriever",
+    "HybridRetriever",
+    "FastInsightRetriever",
+    "GraphRAGPipeline",
+    "GraphRAGService",
+]

graphcontainer-0.1.0/src/graphcontainer/adapters/__init__.py

@@ -0,0 +1,35 @@
+# src/GraphContainer/adapters/__init__.py
+from .base import GraphAdapter, GraphAdapterError, UnsupportedSourceError
+from .fastinsight import FastInsightAdapter, import_graph_from_fastinsight
+from .expla_graphs import ExplaGraphsAdapter, import_graph_from_expla_graphs
+from .freebasekg import FreebaseKGAdapter, import_graph_from_freebasekg
+from .g_retriever import GRetrieverAdapter, import_graph_from_g_retriever
+from .lightrag import LightRAGAdapter, import_graph_from_lightrag
+from .hipporag import HippoRAGAdapter, import_graph_from_hipporag
+
+import_graph_from_component_graph = import_graph_from_fastinsight
+import_graph_from_attribute_bundle_graph = import_graph_from_lightrag
+import_graph_from_topology_semantic_graph = import_graph_from_hipporag
+import_graph_from_subgraph_union_graph = import_graph_from_g_retriever
+
+__all__ = [
+    "GraphAdapter",
+    "GraphAdapterError",
+    "UnsupportedSourceError",
+    "FastInsightAdapter",
+    "ExplaGraphsAdapter",
+    "FreebaseKGAdapter",
+    "GRetrieverAdapter",
+    "LightRAGAdapter",
+    "HippoRAGAdapter",
+    "import_graph_from_component_graph",
+    "import_graph_from_attribute_bundle_graph",
+    "import_graph_from_topology_semantic_graph",
+    "import_graph_from_subgraph_union_graph",
+    "import_graph_from_fastinsight",
+    "import_graph_from_expla_graphs",
+    "import_graph_from_freebasekg",
+    "import_graph_from_lightrag",
+    "import_graph_from_hipporag",
+    "import_graph_from_g_retriever",
+]

graphcontainer-0.1.0/src/graphcontainer/adapters/base.py

@@ -0,0 +1,50 @@
+# src/GraphContainer/adapters/base.py
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Optional
+
+from ..core import SimpleGraphContainer
+
+
+class GraphAdapterError(RuntimeError):
+    """Base error for adapter-level failures."""
+
+
+class UnsupportedSourceError(GraphAdapterError):
+    """Raised when an adapter cannot import the given source."""
+
+
+class GraphAdapter(ABC):
+    """Base interface for importing / exporting graphs."""
+
+    def __init__(self, *, name: str, version: str = "0.1.0"):
+        self.name = name
+        self.version = version
+
+    @abstractmethod
+    def can_import(self, source: Any) -> bool:
+        """Return True if this adapter can import the given source."""
+
+    @abstractmethod
+    def import_graph(
+        self,
+        source: Any,
+        container: Optional[SimpleGraphContainer] = None,
+        *,
+        keep_source_reference: bool = False,
+    ) -> SimpleGraphContainer:
+        """Load a graph from source into a container.
+
+        keep_source_reference is adapter-defined optional metadata.
+        """
+
+    @abstractmethod
+    def export_graph(
+        self,
+        container: SimpleGraphContainer,
+        destination: Any,
+        *,
+        overwrite: bool = False,
+    ) -> Dict[str, Any]:
+        """Serialize container into destination format and return result metadata."""