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#

json

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

Configuration Details#

ParameterTypeDefaultDescriptionhoststringrequiredTigerGraph server URLrestpp_portinteger9000REST++ API portgraph_namestringrequiredGraph name to work withapi_tokenstringrequiredAuthentication tokentimeoutinteger30Request timeout in secondsretry_countinteger3Number of retriesusernamestringoptionalAlternative authenticationpasswordstringoptionalAlternative 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:

gsql

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#

gsql

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

Vertex Pattern Matching#

Query Single Vertex Type

gsql

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

Query Multiple Vertex Types

gsql

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

Traversal Patterns#

Single-Hop Traversal

gsql

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

Multi-Hop Traversal

gsql

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

Variable-Length Traversal

gsql

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

Aggregation Patterns#

Count Aggregation

gsql

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

Property Aggregation

gsql

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

Filtering Patterns#

Where Clause

gsql

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

Having Clause

gsql

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#

json

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

Insert Edges#

json

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

Batch Loading#

CSV File Loading

python

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

---

Graph Algorithms#

Built-In Algorithms#

PageRank

gsql

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

Measures vertex importance in the graph.

Shortest Path

gsql

RUN QUERY shortest_path(source_vertex, target_vertex)

Finds shortest path between two vertices.

Community Detection

gsql

RUN QUERY louvain_community(resolution=1.0)

Detects communities/clusters in graph.

Centrality Analysis

gsql

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#

python

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

Query with Timeout#

python

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

Batch Query Execution#

python

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

---

Error Handling#

Common Error Scenarios#

ErrorCauseSolutionConnection refusedServer not runningStart TigerGraph serverUnauthorizedInvalid tokenRegenerate API tokenQuery not foundQuery not installedInstall query definitionTimeoutQuery too slowOptimize query, increase timeoutGraph not foundWrong graph nameVerify graph name

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#

LibraryPurposepyTigerGraphOfficial Python SDKrequestsHTTP clientjsonJSON handling

Installation#

bash

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#

python

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

Common Operations#

python

# 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#

python

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