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

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 Handling Best Practices

1. Validate Connections - Check before operations
2. Handle Retries - Implement exponential backoff
3. Log Errors - Track all errors for debugging
4. Graceful Degradation - Handle partial failures
5. 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

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

• TigerGraph Official Documentation
• GSQL Reference
• REST++ API Guide
• Python pyTigerGraph

Version: 1.0.0

Last Updated: April 12, 2026