Knowledge Graph - Tigergraph Connector

API key required

Connect to TigerGraph distributed graph database to query, load, and manage large-scale knowledge graph data using GSQL and REST++ APIs

Install

openclaw skills install knowledge-graph-tigergraph-connector

TigerGraph Connector

Purpose

This skill enables comprehensive interaction with TigerGraph graph database for storing, querying, analyzing, and managing large-scale knowledge graph data.

TigerGraph is a high-performance distributed graph database platform optimized for:

Large-scale graph analytics
Real-time graph processing
Advanced graph algorithms
Distributed graph computing
Enterprise-grade reliability

Key Capabilities

Execute GSQL queries on TigerGraph instances
Load vertices and edges via REST++ APIs
Run built-in and custom graph algorithms
Perform real-time graph analytics
Manage graph schema and data
Query result mapping to Python objects
Batch data loading
Performance optimization

When To Use This Skill

Use this skill when:

Querying TigerGraph: Executing GSQL queries and algorithms
Loading Data: Inserting vertices and edges into graph
Graph Analytics: Running PageRank, community detection, etc.
Large-Scale Graphs: Processing enterprise-scale knowledge graphs
Real-Time Analysis: Performing real-time graph computations
Pattern Matching: Finding complex patterns in graph data

Example Triggers

"Execute this GSQL query"
"Run PageRank algorithm"
"Insert vertices into TigerGraph"
"Find shortest path between nodes"
"Detect communities in the graph"
"Get graph statistics and metrics"

Connection Configuration

Connection Parameters

{
  "host": "http://localhost",
  "restpp_port": 9000,
  "graph_name": "MyGraph",
  "api_token": "your-api-token",
  "timeout": 30,
  "retry_count": 3
}

Configuration Details

Parameter	Type	Default	Description
host	string	required	TigerGraph server URL
restpp_port	integer	9000	REST++ API port
graph_name	string	required	Graph name to work with
api_token	string	required	Authentication token
timeout	integer	30	Request timeout in seconds
retry_count	integer	3	Number of retries
username	string	optional	Alternative authentication
password	string	optional	Alternative authentication

Authentication Methods

API Token (preferred)
Username/Password
Custom headers

Core Concepts

GSQL (Graph Search Query Language)

Turing-Complete: Supports complex computations
Pattern Matching: Efficiently matches graph patterns
Algorithm Support: Built-in library of graph algorithms
Vertex/Edge Access: Direct access to graph structure
Aggregation: Built-in aggregation functions

Example Query:

CREATE QUERY getNeighbors(VERTEX<Person> person) FOR GRAPH MyGraph {
  Start = {person};
  Result = SELECT t
           FROM Start:s -(KNOWS:e)-> Person:t;
  PRINT Result;
}

Graph Schema

Vertex Types

Define entities in the graph
Have properties (attributes)
Can have primary keys
Support custom data types

Edge Types

Define relationships between vertices
Support directional connections
Have properties
Can be undirected

Properties

Store data on vertices/edges
Multiple data types supported
Can be indexed
Support default values

REST++ APIs

HTTP-based interface
JSON request/response format
RESTful endpoint design
Real-time data loading
Query execution

GSQL Query Patterns

Basic Query Structure

CREATE QUERY queryName(PARAMETERS) FOR GRAPH graphName {
  // Variable declarations
  // Pattern matching
  // Aggregations
  // Output
}

Vertex Pattern Matching

Query Single Vertex Type

Start = {Person.*};
Result = SELECT * FROM Start;

Query Multiple Vertex Types

Start = {Person.* UNION Company.*};
Result = SELECT * FROM Start;

Traversal Patterns

Single-Hop Traversal

Result = SELECT t
         FROM Start:s -(KNOWS:e)-> Person:t;

Multi-Hop Traversal

Result = SELECT t
         FROM Start:s -(KNOWS:e)-> Person:t -(WORKS_AT:e2)-> Company:c;

Variable-Length Traversal

Result = SELECT t
         FROM Start:s -(KNOWS:e)->* Person:t;

Aggregation Patterns

Count Aggregation

Result = SELECT COUNT(DISTINCT t)
         FROM Start:s -(KNOWS:e)-> Person:t;

Property Aggregation

Result = SELECT s.name, COUNT(DISTINCT t)
         FROM Start:s -(KNOWS:e)-> Person:t
         GROUP BY s.name;

Filtering Patterns

Where Clause

Result = SELECT *
         FROM Start
         WHERE age > 25 AND status == "active";

Having Clause

Result = SELECT s.name, COUNT(DISTINCT t) as cnt
         FROM Start:s -(KNOWS:e)-> Person:t
         GROUP BY s.name
         HAVING cnt > 5;

Data Loading Operations

Insert Vertices

{
  "vertices": {
    "Person": {
      "alice": {
        "name": "Alice",
        "age": 30,
        "email": "alice@example.com"
      },
      "bob": {
        "name": "Bob",
        "age": 25,
        "email": "bob@example.com"
      }
    }
  }
}

Insert Edges

{
  "edges": {
    "Person": {
      "alice": {
        "KNOWS": {
          "Person": {
            "bob": {
              "since": "2020-01-15"
            }
          }
        }
      }
    }
  }
}

Batch Loading

CSV File Loading

connector.load_from_csv(
    file_path="data.csv",
    vertex_type="Person",
    mapping={"name": "Name", "age": "Age"}
)

Graph Algorithms

Built-In Algorithms

PageRank

RUN QUERY pagerank(max_iterations=100, damping_factor=0.85)

Measures vertex importance in the graph.

Shortest Path

RUN QUERY shortest_path(source_vertex, target_vertex)

Finds shortest path between two vertices.

Community Detection

RUN QUERY louvain_community(resolution=1.0)

Detects communities/clusters in graph.

Centrality Analysis

RUN QUERY betweenness_centrality()

Measures vertex betweenness centrality.

Custom Algorithms

Can be defined using GSQL for specific use cases.

Query Execution Patterns

Simple Query Execution

result = connector.run_query(
    query_name="getNeighbors",
    parameters={"person": "Alice"}
)

Query with Timeout

result = connector.run_query(
    query_name="complexQuery",
    parameters={...},
    timeout=60
)

Batch Query Execution

results = connector.batch_query(
    queries=[
        {"name": "query1", "params": {...}},
        {"name": "query2", "params": {...}}
    ]
)

Error Handling

Common Error Scenarios

Error	Cause	Solution
Connection refused	Server not running	Start TigerGraph server
Unauthorized	Invalid token	Regenerate API token
Query not found	Query not installed	Install query definition
Timeout	Query too slow	Optimize query, increase timeout
Graph not found	Wrong graph name	Verify graph name

Error Handling Best Practices

Validate Connections - Check before operations
Handle Retries - Implement exponential backoff
Log Errors - Track all errors for debugging
Graceful Degradation - Handle partial failures
Timeout Management - Set appropriate timeouts

Best Practices

1. Query Design

✅ Use installed queries for performance
✅ Pre-compile queries instead of dynamic ones
✅ Optimize pattern matching
✅ Use appropriate graph traversal depth
✅ Leverage built-in algorithms

2. Data Loading

✅ Use batch loading for bulk data
✅ Validate data before loading
✅ Use atomic transactions
✅ Monitor loading progress
✅ Handle duplicates appropriately

3. Performance

✅ Create indexes on frequently queried properties
✅ Monitor query execution plans
✅ Use result streaming for large datasets
✅ Cache frequently accessed data
✅ Distribute computation across nodes

4. Schema Management

✅ Design schema for query patterns
✅ Use appropriate data types
✅ Maintain referential integrity
✅ Document schema changes
✅ Version schema updates

5. Analytics

✅ Use built-in graph algorithms
✅ Tune algorithm parameters
✅ Monitor resource usage
✅ Implement incremental updates
✅ Cache algorithm results

6. Scalability

✅ Partition data appropriately
✅ Use distributed loading
✅ Monitor cluster health
✅ Balance load across nodes
✅ Plan capacity growth

7. Security

✅ Protect API tokens
✅ Use HTTPS connections
✅ Implement access control
✅ Audit all operations
✅ Encrypt sensitive data

8. Maintenance

✅ Monitor database health
✅ Regular backups
✅ Update software regularly
✅ Archive old data
✅ Clean up temporary data

Integration with Related Skills

Neo4j Integration

Alternative property graph database
Query language: Cypher vs GSQL
Scale and deployment models differ

JanusGraph Connector

Distributed graph storage
Different architecture and use cases
Complementary strengths

RDF Triple Store Integration

Semantic web alternative
Triple-based vs property graph
Different query languages

Graph Query Optimization

Optimize GSQL query performance
Analyze execution plans
Performance tuning

REST API Wrapper

Expose TigerGraph via REST API
Custom endpoint creation
API documentation

Libraries & Dependencies

Core Libraries

Library	Purpose
pyTigerGraph	Official Python SDK
requests	HTTP client
json	JSON handling

Installation

pip install pyTigerGraph requests

Expected Benefits

Using this skill enables:

✅ Performance - High-speed graph processing at scale
✅ Analytics - Advanced graph algorithms and analytics
✅ Scalability - Enterprise-scale knowledge graph processing
✅ Real-Time - Real-time graph computations
✅ Flexibility - Support for complex graph patterns
✅ Reliability - Enterprise-grade reliability and backup
✅ Integration - Easy integration with applications

Quick Reference

Connection & Query

connector = TigerGraphConnector()
connector.connect(config)
result = connector.run_query("queryName", params)
connector.close()

Common Operations

# Insert vertices
connector.insert_vertices(vertex_type, vertices)

# Insert edges
connector.insert_edges(edge_type, edges)

# Run algorithm
connector.run_algorithm("pagerank", params)

# Get statistics
stats = connector.get_statistics()

Data Loading

connector.load_from_csv(file_path, vertex_type, mapping)
connector.batch_insert(vertices, edges)

Related Skills

Neo4j Integration - Property graph database using Cypher
JanusGraph Connector - Distributed graph using Gremlin
RDF Triple Store Integration - SPARQL for RDF
GraphQL Graph Mapping - GraphQL API interface
Graph Query Optimization - Query performance tuning
REST API Wrapper - REST interface for graphs

Resources

Version: 1.0.0
Last Updated: April 12, 2026