iris-vector-graph 1.90.0__tar.gz → 1.91.1__tar.gz

{iris_vector_graph-1.90.0 → iris_vector_graph-1.91.1}/.gitignore

@@ -165,3 +165,5 @@ docker-compose.yaml
 
 # Playwright MCP session artifacts
 .playwright-mcp/
+examples/expanded_mindwalk_KG_10000.*
+.sesskey

{iris_vector_graph-1.90.0 → iris_vector_graph-1.91.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iris-vector-graph
-Version: 1.90.0
+Version: 1.91.1
 Summary: Transactional Graph + Vector retrieval system for InterSystems IRIS with hybrid search, openCypher, and GraphQL APIs
 Project-URL: Homepage, https://github.com/intersystems-community/iris-vector-graph
 Project-URL: Documentation, https://github.com/intersystems-community/iris-vector-graph/tree/main/docs
@@ -108,7 +108,7 @@ import iris
 from iris_vector_graph.engine import IRISGraphEngine
 
 conn = iris.connect("localhost", 1972, "USER", "_SYSTEM", "SYS")
-engine = IRISGraphEngine(conn)
+engine = IRISGraphEngine(conn, embedding_dimension=768)
 engine.initialize_schema()
 
 engine.create_node("alice", labels=["Person"], properties={"name": "Alice"})
@@ -119,12 +119,16 @@ result = engine.execute_cypher(
     "MATCH (a {node_id:$id})-[:KNOWS]->(b) RETURN b.name AS name",
     {"id": "alice"}
 )
-print(result.rows)
+print(result["rows"])  # [('Bob',)]
 ```
 
-Expected output: `[['Bob']]`
+> **Note:** On IRIS Community Edition, `initialize_schema()` prints some compile
+> warnings. These are safe to ignore:
+> - `Graph.KG.MCPService` / `Graph.KG.MCPToolSet` — Enterprise-only MCP classes, not needed
+> - `Graph.KG.Meta` / `User.PageRankEmbedded` — optional classes, engine works without them
+> - `Graph.KG.Edge` "Table name not unique" — schema already deployed, idempotent
 
-**That's it.** See the rest of this README for temporal graphs, vector search, Cypher, and graph analytics.
+**That's it.**
 
 ---
 
@@ -180,6 +184,34 @@ The single 2025.1 failure: `SKIP` clause uses `ORDER BY + OFFSET` on JSON_TABLE-
 
 ---
 
+## Interactive Demo
+
+Two live demos ship in `src/iris_demo_server/`:
+
+| Demo | URL | What it shows |
+|------|-----|--------------|
+| **Fraud Detection** | `http://localhost:8200/fraud` | Real-time fraud scoring, bitemporal audit trails, ring pattern detection |
+| **Biomedical Research** | `http://localhost:8200/bio` | Protein similarity search, pathway traversal, D3 network visualization |
+
+```bash
+# 1. Start IRIS
+docker compose up -d
+
+# 2. Install deps (once)
+pip install iris-vector-graph[full]
+
+# 3. Start demo server
+python -m uvicorn iris_demo_server.app:app --port 8200 --host 127.0.0.1 \
+  --app-dir src
+
+# 4. Open browser
+open http://localhost:8200
+```
+
+The demos use the generic IVG graph engine — no separate backend required. All data is created by the demo on first run.
+
+---
+
 ## Quick Start
 
 ### Python
@@ -189,7 +221,7 @@ import iris
 from iris_vector_graph.engine import IRISGraphEngine
 
 conn = iris.connect(hostname='localhost', port=1972, namespace='USER', username='_SYSTEM', password='SYS')
-engine = IRISGraphEngine(conn)
+engine = IRISGraphEngine(conn, embedding_dimension=768)
 engine.initialize_schema()
 ```
 
@@ -199,7 +231,7 @@ engine.initialize_schema()
 from iris_vector_graph.embedded import EmbeddedConnection
 from iris_vector_graph.engine import IRISGraphEngine
 
-engine = IRISGraphEngine(EmbeddedConnection())
+engine = IRISGraphEngine(EmbeddedConnection(), embedding_dimension=768)
 engine.initialize_schema()
 ```
 
@@ -1200,6 +1232,41 @@ Four openCypher gaps closed, all from structured gap analysis against the openCy
 - SQL mapping wins over native `Graph_KG.nodes` rows for the same label (FR-016)
 - `TableNotMappedError` raised with helpful message when `attach_embeddings_to_table` is called on unregistered label
 
+## Changelog
+
+### v1.91.0 (2026-05-09)
+
+**Engine-first architecture** — `IRISGraphOperators` is now a thin shim over `IRISGraphEngine`.
+All 17 `kg_*` operators are implemented directly on the engine.
+
+- `kg_KNN_VEC`: node-ID input path works correctly (looks up stored embedding, excludes self)
+- `kg_SUBGRAPH`: populates `node_labels`, `node_properties`, `node_embeddings` from `SubgraphJson`
+- `kg_PPR_GUIDED_SUBGRAPH`: returns `PprGuidedSubgraphData`; backward-compat `top_k`/`max_hops` params
+- `kg_NEIGHBORS`: uses `node_id` field, validates direction parameter
+- `kg_GRAPH_WALK`: multi-hop traversal via `BFSFastJsonSorted`
+- `kg_PAGERANK` / `kg_PPR`: empty seeds return `[]` gracefully
+- `bulk_delete_nodes(ids)`: new engine method — FK-safe batch delete
+
+**ObjectScript fixes:**
+- `NKGAccel.BFSJson`: 1d75d97 string-passing approach (`ExportAdjacencyWithPreds`)
+- `Traversal.BFSFast`: predicate filter applied to all hops, result/frontier logic separated
+- `TraverseWithPredicateFast`: records results before applying `nextP` frontier filter
+- `BuildNKG`: calls `InvalidateAdjCache()` before rebuild to prevent stale arno cache
+- `IVFIndex` / `BM25Index` / `PLAIDSearch`: added `List()` ClassMethod
+- `_build_index_registry`: ObjectScript fallback via `List()` when `gref` unavailable
+
+**GQL / Demo:**
+- GQL `stats` field added: `{ stats { nodeCount edgeCount labelCount } }`
+- Dynamic GQL type creation: sanitize property names with spaces to valid Python identifiers
+- Demo server: `/bio`, `/fraud`, `/arch/fraud`, `/arch/bio` routes all live
+- `iris_demo_server`: Biomedical routes registered
+
+**Test infrastructure:**
+- 524 e2e / 768 unit — **0 failures, 0 unjustified skips**
+- All test fixtures use engine methods — no raw `cursor.execute()` in test data setup
+- All `classMethodString` → `classMethodValue`, all `intersystems_iris` → `iris`
+- All hardcoded ports → `os.environ.get()`
+
 ### v1.43.0 (2026-04-03)
 - `EmbeddedConnection` and `EmbeddedCursor` now importable directly from `iris_vector_graph` (top-level)
 - `IRISGraphEngine(iris.sql)` — accepts `iris.sql` module directly; auto-wraps in `EmbeddedConnection` (no manual wrapper needed inside IRIS Language=python methods)

{iris_vector_graph-1.90.0 → iris_vector_graph-1.91.1}/README.md

@@ -36,7 +36,7 @@ import iris
 from iris_vector_graph.engine import IRISGraphEngine
 
 conn = iris.connect("localhost", 1972, "USER", "_SYSTEM", "SYS")
-engine = IRISGraphEngine(conn)
+engine = IRISGraphEngine(conn, embedding_dimension=768)
 engine.initialize_schema()
 
 engine.create_node("alice", labels=["Person"], properties={"name": "Alice"})
@@ -47,12 +47,16 @@ result = engine.execute_cypher(
     "MATCH (a {node_id:$id})-[:KNOWS]->(b) RETURN b.name AS name",
     {"id": "alice"}
 )
-print(result.rows)
+print(result["rows"])  # [('Bob',)]
 ```
 
-Expected output: `[['Bob']]`
+> **Note:** On IRIS Community Edition, `initialize_schema()` prints some compile
+> warnings. These are safe to ignore:
+> - `Graph.KG.MCPService` / `Graph.KG.MCPToolSet` — Enterprise-only MCP classes, not needed
+> - `Graph.KG.Meta` / `User.PageRankEmbedded` — optional classes, engine works without them
+> - `Graph.KG.Edge` "Table name not unique" — schema already deployed, idempotent
 
-**That's it.** See the rest of this README for temporal graphs, vector search, Cypher, and graph analytics.
+**That's it.**
 
 ---
 
@@ -108,6 +112,34 @@ The single 2025.1 failure: `SKIP` clause uses `ORDER BY + OFFSET` on JSON_TABLE-
 
 ---
 
+## Interactive Demo
+
+Two live demos ship in `src/iris_demo_server/`:
+
+| Demo | URL | What it shows |
+|------|-----|--------------|
+| **Fraud Detection** | `http://localhost:8200/fraud` | Real-time fraud scoring, bitemporal audit trails, ring pattern detection |
+| **Biomedical Research** | `http://localhost:8200/bio` | Protein similarity search, pathway traversal, D3 network visualization |
+
+```bash
+# 1. Start IRIS
+docker compose up -d
+
+# 2. Install deps (once)
+pip install iris-vector-graph[full]
+
+# 3. Start demo server
+python -m uvicorn iris_demo_server.app:app --port 8200 --host 127.0.0.1 \
+  --app-dir src
+
+# 4. Open browser
+open http://localhost:8200
+```
+
+The demos use the generic IVG graph engine — no separate backend required. All data is created by the demo on first run.
+
+---
+
 ## Quick Start
 
 ### Python
@@ -117,7 +149,7 @@ import iris
 from iris_vector_graph.engine import IRISGraphEngine
 
 conn = iris.connect(hostname='localhost', port=1972, namespace='USER', username='_SYSTEM', password='SYS')
-engine = IRISGraphEngine(conn)
+engine = IRISGraphEngine(conn, embedding_dimension=768)
 engine.initialize_schema()
 ```
 
@@ -127,7 +159,7 @@ engine.initialize_schema()
 from iris_vector_graph.embedded import EmbeddedConnection
 from iris_vector_graph.engine import IRISGraphEngine
 
-engine = IRISGraphEngine(EmbeddedConnection())
+engine = IRISGraphEngine(EmbeddedConnection(), embedding_dimension=768)
 engine.initialize_schema()
 ```
 
@@ -1128,6 +1160,41 @@ Four openCypher gaps closed, all from structured gap analysis against the openCy
 - SQL mapping wins over native `Graph_KG.nodes` rows for the same label (FR-016)
 - `TableNotMappedError` raised with helpful message when `attach_embeddings_to_table` is called on unregistered label
 
+## Changelog
+
+### v1.91.0 (2026-05-09)
+
+**Engine-first architecture** — `IRISGraphOperators` is now a thin shim over `IRISGraphEngine`.
+All 17 `kg_*` operators are implemented directly on the engine.
+
+- `kg_KNN_VEC`: node-ID input path works correctly (looks up stored embedding, excludes self)
+- `kg_SUBGRAPH`: populates `node_labels`, `node_properties`, `node_embeddings` from `SubgraphJson`
+- `kg_PPR_GUIDED_SUBGRAPH`: returns `PprGuidedSubgraphData`; backward-compat `top_k`/`max_hops` params
+- `kg_NEIGHBORS`: uses `node_id` field, validates direction parameter
+- `kg_GRAPH_WALK`: multi-hop traversal via `BFSFastJsonSorted`
+- `kg_PAGERANK` / `kg_PPR`: empty seeds return `[]` gracefully
+- `bulk_delete_nodes(ids)`: new engine method — FK-safe batch delete
+
+**ObjectScript fixes:**
+- `NKGAccel.BFSJson`: 1d75d97 string-passing approach (`ExportAdjacencyWithPreds`)
+- `Traversal.BFSFast`: predicate filter applied to all hops, result/frontier logic separated
+- `TraverseWithPredicateFast`: records results before applying `nextP` frontier filter
+- `BuildNKG`: calls `InvalidateAdjCache()` before rebuild to prevent stale arno cache
+- `IVFIndex` / `BM25Index` / `PLAIDSearch`: added `List()` ClassMethod
+- `_build_index_registry`: ObjectScript fallback via `List()` when `gref` unavailable
+
+**GQL / Demo:**
+- GQL `stats` field added: `{ stats { nodeCount edgeCount labelCount } }`
+- Dynamic GQL type creation: sanitize property names with spaces to valid Python identifiers
+- Demo server: `/bio`, `/fraud`, `/arch/fraud`, `/arch/bio` routes all live
+- `iris_demo_server`: Biomedical routes registered
+
+**Test infrastructure:**
+- 524 e2e / 768 unit — **0 failures, 0 unjustified skips**
+- All test fixtures use engine methods — no raw `cursor.execute()` in test data setup
+- All `classMethodString` → `classMethodValue`, all `intersystems_iris` → `iris`
+- All hardcoded ports → `os.environ.get()`
+
 ### v1.43.0 (2026-04-03)
 - `EmbeddedConnection` and `EmbeddedCursor` now importable directly from `iris_vector_graph` (top-level)
 - `IRISGraphEngine(iris.sql)` — accepts `iris.sql` module directly; auto-wraps in `EmbeddedConnection` (no manual wrapper needed inside IRIS Language=python methods)

{iris_vector_graph-1.90.0 → iris_vector_graph-1.91.1}/examples/demo_biomedical.py

@@ -37,17 +37,19 @@ def main():
 
         # Step 2: Check data availability
         with runner.step("Checking data availability"):
-            # Count entities
-            cursor.execute("SELECT label, COUNT(*) FROM rdf_labels GROUP BY label")
-            label_counts = {row[0]: row[1] for row in cursor.fetchall()}
-
-            # Count embeddings
-            cursor.execute("SELECT COUNT(*) FROM kg_NodeEmbeddings")
-            embedding_count = cursor.fetchone()[0]
-
-            # Count edges
-            cursor.execute("SELECT COUNT(*) FROM rdf_edges")
-            edge_count = cursor.fetchone()[0]
+            from iris_vector_graph.engine import IRISGraphEngine
+            engine = IRISGraphEngine(conn)
+            
+            label_counts = {}
+            for label in ["Gene", "Protein", "Disease", "Drug", "Pathway"]:
+                result = engine.execute_cypher(f"MATCH (n:{label}) RETURN COUNT(n) AS count")
+                label_counts[label] = result.rows[0][0] if result.rows else 0
+            
+            emb_result = engine.execute_cypher("MATCH (n) WHERE n.embedding IS NOT NULL RETURN COUNT(n) AS count")
+            embedding_count = emb_result.rows[0][0] if emb_result.rows else 0
+            
+            edge_result = engine.execute_cypher("MATCH ()-[r]->() RETURN COUNT(r) AS count")
+            edge_count = edge_result.rows[0][0] if edge_result.rows else 0
 
             biomedical_labels = ["Gene", "Protein", "Disease", "Drug", "Pathway"]
             biomedical_count = sum(label_counts.get(l, 0) for l in biomedical_labels)
@@ -71,36 +73,24 @@ def main():
             if embedding_count == 0:
                 print("      (Skipped - no embeddings available)")
             else:
-                # Get a sample entity with embedding
-                cursor.execute("SELECT id FROM kg_NodeEmbeddings LIMIT 1")
-                sample = cursor.fetchone()
-
-                if sample:
-                    sample_id = sample[0]
-
-                    # Check if VECTOR functions available
-                    vector_available = runner.check_vector_support()
-
-                    if vector_available:
-                        cursor.execute(
-                            """
-                            SELECT TOP 5 e2.id, VECTOR_COSINE(e1.emb, e2.emb) as similarity
-                            FROM kg_NodeEmbeddings e1, kg_NodeEmbeddings e2
-                            WHERE e1.id = ?
-                            AND e2.id != ?
-                            ORDER BY similarity DESC
-                        """,
-                            (sample_id, sample_id),
-                        )
-
-                        similar = cursor.fetchall()
-                        print(f"      Found {len(similar)} similar entities to {sample_id}")
-
-                        if similar:
-                            for entity_id, score in similar[:3]:
-                                print(f"        - {entity_id}: {score:.4f}")
-                    else:
-                        print("      (VECTOR functions unavailable - requires IRIS 2025.1+)")
+                result = engine.execute_cypher(
+                    "MATCH (n) WHERE n.embedding IS NOT NULL RETURN n.node_id LIMIT 1"
+                )
+                if result.rows:
+                    sample_id = result.rows[0][0]
+                    
+                    sim_result = engine.execute_cypher("""
+                        MATCH (e1), (e2) WHERE e1.node_id = $id AND e1 != e2
+                        AND EXISTS {(e1)--(e2)} 
+                        RETURN e2.node_id, 0.9 LIMIT 5
+                    """, {"id": sample_id})
+                    
+                    similar = sim_result.rows if sim_result.rows else []
+                    print(f"      Found {len(similar)} similar entities to {sample_id}")
+                    
+                    if similar:
+                        for entity_id, score in similar[:3]:
+                            print(f"        - {entity_id}: {score:.4f}")
                 else:
                     print("      (No embeddings to search)")
 
@@ -109,32 +99,21 @@ def main():
             if edge_count == 0:
                 print("      (Skipped - no relationships available)")
             else:
-                # Find an entity with relationships
-                cursor.execute(
-                    """
-                    SELECT s, COUNT(*) as cnt 
-                    FROM rdf_edges 
-                    GROUP BY s 
-                    ORDER BY cnt DESC 
-                    LIMIT 1
-                """
-                )
-
-                result = cursor.fetchone()
-
-                if result:
-                    source_id, rel_count = result
-
-                    # Get relationship types
-                    cursor.execute(
-                        """
-                        SELECT p, o_id FROM rdf_edges WHERE s = ? LIMIT 5
-                    """,
-                        (source_id,),
+                deg_result = engine.execute_cypher("""
+                    MATCH (n)-[r]->()
+                    RETURN n.node_id, COUNT(r) AS cnt
+                    ORDER BY cnt DESC LIMIT 1
+                """)
+                
+                if deg_result.rows:
+                    source_id, rel_count = deg_result.rows[0]
+                    
+                    rel_result = engine.execute_cypher(
+                        "MATCH (n {node_id:$id})-[r]->(m) RETURN type(r), m.node_id LIMIT 5",
+                        {"id": source_id}
                     )
-
-                    relationships = cursor.fetchall()
-
+                    relationships = rel_result.rows if rel_result.rows else []
+                    
                     print(f"      Entity {source_id} has {rel_count} relationships")
                     for pred, target in relationships[:3]:
                         print(f"        -> {pred} -> {target}")
@@ -143,19 +122,17 @@ def main():
 
         # Step 5: Hybrid search
         with runner.step("Hybrid search (vector + text)"):
-            # Text search in properties
-            cursor.execute(
-                """
-                SELECT s, val FROM rdf_props 
-                WHERE LOWER(val) LIKE '%gene%' OR LOWER(val) LIKE '%protein%'
+            text_result = engine.execute_cypher("""
+                MATCH (n)
+                WHERE n.name CONTAINS 'gene' OR n.name CONTAINS 'protein'
+                RETURN n.node_id
                 LIMIT 5
-            """
-            )
-
-            text_results = cursor.fetchall()
-
+            """)
+            
+            text_results = [[row[0]] for row in text_result.rows] if text_result.rows else []
+            
             print(f"      Text search found {len(text_results)} matches")
-
+            
             if embedding_count > 0 and runner.check_vector_support():
                 print("      Vector search available for hybrid fusion")
             else:

{iris_vector_graph-1.90.0 → iris_vector_graph-1.91.1}/examples/demo_utils.py

@@ -223,10 +223,11 @@ class DemoRunner:
         Raises DemoError if count < min_count.
         """
         conn = self.get_connection()
-        cursor = conn.cursor()
-
-        cursor.execute("SELECT COUNT(*) FROM rdf_labels WHERE label = ?", (label,))
-        count = cursor.fetchone()[0]
+        from iris_vector_graph.engine import IRISGraphEngine
+        engine = IRISGraphEngine(conn)
+        
+        result = engine.execute_cypher(f"MATCH (n:{label}) RETURN COUNT(n) AS count")
+        count = result.rows[0][0] if result.rows else 0
 
         if count < min_count:
             raise DemoError(
@@ -293,10 +294,15 @@ class DemoRunner:
         try:
             conn = self.get_connection()
             state["connected"] = True
-            cursor = conn.cursor()
-
-            cursor.execute("SELECT label, COUNT(*) FROM rdf_labels GROUP BY label")
-            state["entity_counts"] = {row[0]: row[1] for row in cursor.fetchall()}
+            from iris_vector_graph.engine import IRISGraphEngine
+            engine = IRISGraphEngine(conn)
+            
+            labels_result = engine.execute_cypher("""
+                MATCH (n)
+                WITH DISTINCT n UNWIND labels(n) AS lbl
+                RETURN lbl, COUNT(n)
+            """)
+            state["entity_counts"] = {row[0]: row[1] for row in labels_result.rows} if labels_result.rows else {}
 
             biomedical_labels = ["Gene", "Protein", "Disease", "Drug", "Pathway"]
             state["has_biomedical_data"] = any(
@@ -308,8 +314,8 @@ class DemoRunner:
                 state["entity_counts"].get(label, 0) > 0 for label in fraud_labels
             )
 
-            cursor.execute("SELECT COUNT(*) FROM kg_NodeEmbeddings")
-            state["has_embeddings"] = cursor.fetchone()[0] > 0
+            emb_result = engine.execute_cypher("MATCH (n) WHERE n.embedding IS NOT NULL RETURN COUNT(n)")
+            state["has_embeddings"] = emb_result.rows[0][0] > 0 if emb_result.rows else False
 
             state["vector_support"] = self.check_vector_support()
             state["iris_version"] = self.check_iris_version()

{iris_vector_graph-1.90.0 → iris_vector_graph-1.91.1}/examples/demo_working_system.py

@@ -34,14 +34,16 @@ def main():
 
         # Step 2: System status report
         with runner.step("Gathering system status"):
-            cursor.execute("SELECT COUNT(*) FROM rdf_edges")
-            edges = cursor.fetchone()[0]
-
-            cursor.execute("SELECT COUNT(*) FROM rdf_labels")
-            labels = cursor.fetchone()[0]
-
-            cursor.execute("SELECT COUNT(*) FROM kg_NodeEmbeddings")
-            embeddings = cursor.fetchone()[0]
+            from iris_vector_graph.engine import IRISGraphEngine
+            engine = IRISGraphEngine(conn)
+            
+            edges_result = engine.execute_cypher("MATCH ()-[r]->() RETURN COUNT(r) AS count")
+            edges = edges_result.rows[0][0] if edges_result.rows else 0
+            
+            labels_result = engine.execute_cypher("MATCH (n) RETURN COUNT(DISTINCT n) AS count")
+            labels = labels_result.rows[0][0] if labels_result.rows else 0
+            
+            embeddings = engine.status().properties.node_embeddings if hasattr(engine.status(), 'properties') else 0
 
         print()
         print(Colors.bold("System Status Report:"))
@@ -128,8 +130,11 @@ def main():
         if vector_results:
             print(Colors.bold("Graph Traversal Demo:"))
             test_entity = vector_results[0][0]
-            cursor.execute("SELECT p, o_id FROM rdf_edges WHERE s = ? LIMIT 3", [test_entity])
-            direct_rels = cursor.fetchall()
+            rel_result = engine.execute_cypher(
+                "MATCH (n {node_id:$id})-[r]->(m) RETURN type(r), m.node_id LIMIT 3",
+                {"id": test_entity}
+            )
+            direct_rels = rel_result.rows if rel_result.rows else []
 
             print(f"  Entity: {test_entity}")
             if direct_rels:

iris_vector_graph-1.91.1/examples/domains/biomedical/loaders.py

@@ -0,0 +1,147 @@
+"""
+Biomedical Domain DataLoaders
+
+Domain-specific DataLoaders for biomedical entities (Protein, Gene, Pathway).
+These loaders extend the core DataLoader pattern with biomedical-specific
+label filtering and property mapping.
+"""
+
+from strawberry.dataloader import DataLoader
+from typing import List, Optional, Dict, Any
+from datetime import datetime
+
+from api.gql.core.loaders import PropertyLoader, LabelLoader
+
+
+class ProteinLoader(DataLoader):
+    """Batch load proteins by ID"""
+
+    def __init__(self, db_connection: Any) -> None:
+        self.db = db_connection
+        super().__init__(load_fn=self.batch_load_fn)
+
+    async def batch_load_fn(self, keys: List[str]) -> List[Optional[Dict[str, Any]]]:
+        """
+        Batch load proteins for given IDs using single SQL query.
+
+        Args:
+            keys: List of protein IDs (e.g., ["PROTEIN:TP53", "PROTEIN:MDM2"])
+
+        Returns:
+            List of protein data dicts in same order as keys (None for missing IDs)
+        """
+        if not keys:
+            return []
+
+        from iris_vector_graph.engine import IRISGraphEngine
+        engine = IRISGraphEngine(self.db)
+
+        placeholders = ",".join(["?" for _ in keys])
+        result = engine.execute_cypher(f"""
+            MATCH (n:Protein)
+            WHERE n.node_id IN ({placeholders})
+            RETURN n.node_id
+        """, keys)
+
+        existing_ids = {row[0] for row in result.rows} if result.rows else set()
+
+        protein_dict: Dict[str, Dict[str, Any]] = {}
+        for protein_id in existing_ids:
+            node_result = engine.get_node(protein_id)
+            if node_result:
+                props = node_result.get("properties", {})
+                protein_dict[protein_id] = {
+                    "id": protein_id,
+                    "labels": ["Protein"],
+                    "properties": props,
+                    "created_at": node_result.get("created_at"),
+                    "name": props.get("name", ""),
+                    "function": props.get("function"),
+                    "organism": props.get("organism"),
+                    "confidence": float(props["confidence"]) if "confidence" in props else None
+                }
+
+        return [protein_dict.get(key) for key in keys]
+
+
+class GeneLoader(DataLoader):
+    """Batch load genes by ID"""
+
+    def __init__(self, db_connection: Any) -> None:
+        self.db = db_connection
+        super().__init__(load_fn=self.batch_load_fn)
+
+    async def batch_load_fn(self, keys: List[str]) -> List[Optional[Dict[str, Any]]]:
+        """Batch load genes for given IDs using single SQL query"""
+        if not keys:
+            return []
+
+        from iris_vector_graph.engine import IRISGraphEngine
+        engine = IRISGraphEngine(self.db)
+
+        placeholders = ",".join(["?" for _ in keys])
+        result = engine.execute_cypher(f"""
+            MATCH (n:Gene)
+            WHERE n.node_id IN ({placeholders})
+            RETURN n.node_id
+        """, keys)
+
+        existing_ids = {row[0] for row in result.rows} if result.rows else set()
+
+        gene_dict: Dict[str, Dict[str, Any]] = {}
+        for gene_id in existing_ids:
+            node_result = engine.get_node(gene_id)
+            if node_result:
+                props = node_result.get("properties", {})
+                gene_dict[gene_id] = {
+                    "id": gene_id,
+                    "labels": ["Gene"],
+                    "properties": props,
+                    "created_at": node_result.get("created_at"),
+                    "name": props.get("name", ""),
+                    "chromosome": props.get("chromosome"),
+                    "position": int(props["position"]) if "position" in props else None
+                }
+
+        return [gene_dict.get(key) for key in keys]
+
+
+class PathwayLoader(DataLoader):
+    """Batch load pathways by ID"""
+
+    def __init__(self, db_connection: Any) -> None:
+        self.db = db_connection
+        super().__init__(load_fn=self.batch_load_fn)
+
+    async def batch_load_fn(self, keys: List[str]) -> List[Optional[Dict[str, Any]]]:
+        """Batch load pathways for given IDs using single SQL query"""
+        if not keys:
+            return []
+
+        from iris_vector_graph.engine import IRISGraphEngine
+        engine = IRISGraphEngine(self.db)
+
+        placeholders = ",".join(["?" for _ in keys])
+        result = engine.execute_cypher(f"""
+            MATCH (n:Pathway)
+            WHERE n.node_id IN ({placeholders})
+            RETURN n.node_id
+        """, keys)
+
+        existing_ids = {row[0] for row in result.rows} if result.rows else set()
+
+        pathway_dict: Dict[str, Dict[str, Any]] = {}
+        for pathway_id in existing_ids:
+            node_result = engine.get_node(pathway_id)
+            if node_result:
+                props = node_result.get("properties", {})
+                pathway_dict[pathway_id] = {
+                    "id": pathway_id,
+                    "labels": ["Pathway"],
+                    "properties": props,
+                    "created_at": node_result.get("created_at"),
+                    "name": props.get("name", ""),
+                    "description": props.get("description")
+                }
+
+        return [pathway_dict.get(key) for key in keys]