my skill -names

---

name: tigergraph_connector description: Connect to TigerGraph distributed graph database to query, load, and manage large-scale knowledge graph data using GSQL and REST++ APIs category: integrations tags: - knowledge-graph - tigergraph - graph-database - gsql - graph-analytics - distributed-graph - real-time-analytics - graph-algorithms - integration version: 1.0.0 author: kg-dev-skills

---

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

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

| 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

TigerGraph Official Documentation

GSQL Reference

REST++ API Guide

Python pyTigerGraph

---

Status: ✅ Production Ready Version: 1.0.0 Last Updated: April 12, 2026

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

---