TrustGraph vs Graphlit

TrustGraph and Graphlit are both Knowledge Graph platforms for AI applications, but they differ fundamentally in deployment model, data sovereignty, and openness: self-hosted open source versus managed cloud API.

At a Glance

Core Philosophy

TrustGraph: Open Source, Self-Hosted Platform

TrustGraph provides full ownership and control:

# Deploy on your infrastructure
git clone https://github.com/trustgraph-ai/trustgraph
cd trustgraph

# Run with Docker Compose
docker compose -f trustgraph_system.yaml up -d

# Or deploy to Kubernetes
kubectl apply -f k8s/

# Or deploy to any cloud (AWS, Azure, GCP)
terraform apply

# Full access to:
# - Source code
# - Configuration
# - Data storage
# - Customization
# - Scaling strategy

// SDK connects to YOUR deployment
import { TrustGraph } from "@trustgraph/sdk";

const trustgraph = new TrustGraph({
  endpoint: "https://your-internal-deployment.company.com",
  // Data never leaves your infrastructure
});

// Full transparency and control
await trustgraph.ingest({
  sources: ["s3://your-bucket/sensitive-docs/"],
  graphConfig: "custom-ontology.ttl",
});

Key characteristics:

• Complete data sovereignty
• Full source code access
• Deploy anywhere (cloud, on-premise, hybrid)
• Customize everything
• No vendor lock-in

Graphlit: Managed Cloud API Platform

Graphlit provides serverless convenience:

// SDK connects to Graphlit's cloud
import { Graphlit } from "@graphlit/client";

const graphlit = new Graphlit({
  token: process.env.GRAPHLIT_TOKEN,
  organizationId: "your-org-id",
  environmentId: "your-env-id",
});

// Data flows to Graphlit's infrastructure
await graphlit.ingestUri({
  uri: "https://your-site.com/document.pdf",
  // Document stored in Graphlit's cloud
});

// Query via API
const results = await graphlit.queryContents({
  filter: "your query",
});

Key characteristics:

• No infrastructure management
• Fully managed service
• API-first access
• Pay-per-use pricing
• Vendor-hosted data

Data Sovereignty & Security

TrustGraph: Complete Control

Your data stays in your infrastructure:

// Deploy in your VPC, on-premise, or air-gapped
const deployment = {
  location: "on-premise",  // or "aws-vpc", "azure-vnet", "gcp-vpc", "air-gapped"
  region: "your-datacenter",
  network: "isolated-network",
  backup: "your-backup-system",
};

// Data residency guaranteed
await trustgraph.ingest({
  sources: ["file:///local/sensitive-documents/"],
  storage: {
    graph: "neo4j://internal-neo4j:7687",
    vector: "qdrant://internal-qdrant:6333",
    // All data stays internal
  },
});

// Compliance controls
await trustgraph.configure({
  encryption: {
    atRest: "AES-256",
    inTransit: "TLS 1.3",
    keyManagement: "your-kms",
  },
  compliance: {
    HIPAA: true,
    GDPR: true,
    SOC2: true,
    dataResidency: "EU",
  },
  audit: {
    enabled: true,
    logRetention: "7 years",
    destination: "your-siem",
  },
});

Benefits:

• Complete data control
• Meet any compliance requirement
• No third-party data access
• Custom security policies
• Air-gap capable

Graphlit: Cloud-Based Storage

Data resides in Graphlit's infrastructure:

// Data sent to Graphlit's cloud
await graphlit.ingestUri({
  uri: "https://example.com/document.pdf",
  // Document processed and stored by Graphlit
});

// Limited control over data location
const config = {
  organizationId: "your-org",
  environmentId: "production",
  // Data residency: Graphlit's cloud regions
};

// Security: Graphlit's responsibility
// Compliance: Depends on Graphlit's certifications
// Access: API only, no direct database access

Considerations:

• Data stored with third party
• Compliance depends on Graphlit's certifications
• Limited control over data location
• API-only access to your data
• Vendor lock-in risk

Deployment & Operations

TrustGraph: Self-Managed Deployment

Multiple deployment options:

# Option 1: Docker Compose (single-node)
services:
  knowledge-graph:
    image: trustgraph/neo4j
  vector-store:
    image: trustgraph/qdrant
  agents:
    image: trustgraph/agents
  api:
    image: trustgraph/api

# Option 2: Kubernetes (production)
apiVersion: apps/v1
kind: Deployment
metadata:
  name: trustgraph-platform
spec:
  replicas: 3
  # ... full K8s deployment

# Option 3: Cloud-specific (AWS, Azure, GCP)
# Terraform configurations provided
# CloudFormation templates available
# ARM templates available

# Option 4: Bare metal / On-premise
# Installation scripts provided
# Ansible playbooks available

Operational responsibilities:

You manage:

• ✅ Infrastructure provisioning
• ✅ Scaling and capacity planning
• ✅ Updates and patches
• ✅ Monitoring and alerting
• ✅ Backup and disaster recovery
• ✅ Security hardening

Benefits:

• ✅ Full control
• ✅ Optimize for your workload
• ✅ No usage limits
• ✅ Predictable costs
• ✅ Custom optimizations

Graphlit: Managed Service

Serverless consumption:

// No infrastructure management
const graphlit = new Graphlit({
  token: process.env.GRAPHLIT_TOKEN,
  // That's it - service is ready
});

// Just use the API
await graphlit.ingestUri({ uri: "..." });
await graphlit.queryContents({ filter: "..." });

// Graphlit handles:
// - Scaling
// - Updates
// - Monitoring
// - Backups
// - Security patches

Operational responsibilities:

Graphlit manages:

• ✅ All infrastructure
• ✅ Automatic scaling
• ✅ Updates and patches
• ✅ Monitoring
• ✅ Backups
• ✅ Security

You manage:

• ⚠️ API integration
• ⚠️ Usage optimization
• ⚠️ Cost management

Trade-offs:

• ⚠️ Limited control
• ⚠️ Vendor dependency
• ⚠️ Usage-based costs can scale
• ⚠️ API rate limits apply

Customization & Extensibility

TrustGraph: Full Customization

Access to everything:

// Customize graph schema
await trustgraph.schema.define({
  ontology: `
    @prefix : <http://your-company.com/ontology#> .
    @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .

    :CustomEntity a rdfs:Class ;
      rdfs:label "Your Custom Entity Type" .

    :customRelationship a rdf:Property ;
      rdfs:domain :CustomEntity ;
      rdfs:range :AnotherEntity .
  `,
});

// Customize processing pipeline
await trustgraph.pipeline.configure({
  stages: [
    { name: "custom-extraction", function: yourCustomExtractor },
    { name: "domain-validation", function: yourValidator },
    { name: "proprietary-linking", function: yourLinker },
  ],
});

// Customize agent behavior
await trustgraph.agents.define({
  name: "custom-analyst",
  capabilities: yourCustomCapabilities,
  reasoning: yourCustomReasoningEngine,
});

// Modify source code
// Fork the repository
git clone https://github.com/trustgraph-ai/trustgraph
cd trustgraph
# Make your changes
# Deploy your version

Extensibility:

• ✅ Modify any component
• ✅ Add custom processing stages
• ✅ Integrate proprietary systems
• ✅ Custom graph schemas
• ✅ Domain-specific optimizations
• ✅ Build on the platform

Graphlit: API-Level Configuration

Configuration within API constraints:

// Configure via API options
await graphlit.createSpecification({
  name: "Custom Processing",
  type: "EXTRACTION",
  // Limited to provided options
  strategies: [
    { type: "GRAPH" },
    { type: "EXTRACTION" },
  ],
});

// Use supported content types
await graphlit.ingest({
  uri: "...",
  type: "DOCUMENT",  // Must be supported type
});

// Query with API capabilities
const results = await graphlit.query({
  filter: "...",
  // Limited to API query options
});

Limitations:

• ⚠️ No source code access
• ⚠️ API-defined capabilities only
• ⚠️ Cannot modify processing pipeline
• ⚠️ Cannot add custom components
• ⚠️ Limited to supported features
• ⚠️ Feature request dependency

Cost Structure

TrustGraph: Infrastructure-Based

Predictable infrastructure costs:

Monthly Cost Breakdown (Example):

Infrastructure:
- Graph database (Neo4j cluster): $500-2000/month
- Vector store (Qdrant): $200-800/month
- Compute (K8s cluster): $1000-5000/month
- Storage: $100-500/month
- Networking: $50-200/month

Total: $1,850-8,500/month

Plus:
- LLM API costs (OpenAI, Anthropic, etc.): Variable
- Optional: Enterprise support: $X/year

Predictability:
✅ Fixed infrastructure costs
✅ Scale infrastructure as needed
✅ No per-request charges
✅ Unlimited usage within your infrastructure
✅ No surprise bills

Best for:
- High-volume applications
- Predictable workloads
- Cost-sensitive deployments

Graphlit: Usage-Based SaaS

Pay-per-use pricing:

Pricing Model (Typical SaaS):

- Per document ingested: $X
- Per query: $Y
- Storage: $Z per GB/month
- Compute: Based on processing time
- API calls: Included or metered

Example:
- 10,000 documents: $X × 10,000
- 100,000 queries/month: $Y × 100,000
- 100 GB storage: $Z × 100
- Plus usage-based compute

Predictability:
⚠️ Costs scale with usage
⚠️ Variable monthly bills
⚠️ High-volume can be expensive
⚠️ Rate limits may apply

Best for:
- Low-volume applications
- Unpredictable workloads
- Rapid prototyping
- Proof-of-concepts

Knowledge Graph Capabilities

TrustGraph: Full Graph Access

Direct graph operations:

// Direct Cypher queries
const result = await trustgraph.graph.query({
  cypher: `
    MATCH (a:Person)-[r:KNOWS*1..3]->(b:Person)
    WHERE a.name = 'Alice'
    RETURN b, length(r) as hops
    ORDER BY hops
  `,
});

// Custom graph algorithms
await trustgraph.graph.algorithm({
  name: "pagerank",
  params: { iterations: 20, dampingFactor: 0.85 },
});

// Graph schema evolution
await trustgraph.graph.migrate({
  from: "schema_v1",
  to: "schema_v2",
  transformations: [...],
});

// Export graph
const graphData = await trustgraph.graph.export({
  format: "graphml",  // or cypher, neo4j, rdf
});

Advantages:

• Full graph query language support
• Custom graph algorithms
• Direct database access
• Schema migrations
• Graph export/import
• Advanced graph analytics

Graphlit: API Query Interface

Query via REST API:

// Query through Graphlit API
const results = await graphlit.queryContents({
  filter: {
    types: ["DOCUMENT"],
    search: "your search term",
  },
});

// GraphQL queries
const response = await graphlit.graphql(`
  query {
    contents(filter: { types: [DOCUMENT] }) {
      results {
        id
        name
        # Limited to exposed fields
      }
    }
  }
`);

Limitations:

• API-exposed operations only
• No direct graph queries
• Limited graph traversal
• Cannot run custom algorithms
• No direct database access
• Dependent on API features

Vector Search & RAG

TrustGraph: Hybrid Approach

Graph + Vector unified:

// Hybrid retrieval strategy
const context = await trustgraph.retrieve({
  query: "AI in healthcare",
  strategy: "graph-rag",

  // Vector search
  vectorTopK: 10,
  vectorModel: "openai-3-large",

  // Graph traversal
  graphDepth: 3,
  relationshipTypes: ["related_to", "influences"],

  // Combination
  fusion: "weighted",
  weights: { vector: 0.4, graph: 0.6 },
});

// Returns combined graph + vector context
{
  vectorMatches: [...],
  graphContext: {
    entities: [...],
    relationships: [...],
    paths: [...],
  },
  fusedResults: [...],
}

Graphlit: Managed RAG

API-provided RAG:

// Query via API
const results = await graphlit.queryContents({
  filter: {
    search: "AI in healthcare",
    types: ["DOCUMENT"],
  },
});

// RAG handled internally
// Limited control over retrieval strategy
// Cannot customize vector/graph fusion

Multi-Tenancy & Isolation

TrustGraph: Flexible Multi-Tenancy

Multiple isolation strategies:

// Option 1: Database-level isolation
await trustgraph.tenant.create({
  id: "tenant-acme",
  isolation: "database",  // Separate databases
  graphDb: "neo4j-acme",
  vectorDb: "qdrant-acme",
});

// Option 2: Graph-level isolation
await trustgraph.tenant.create({
  id: "tenant-globex",
  isolation: "graph",  // Shared DB, isolated graphs
  graphName: "globex-graph",
});

// Option 3: Namespace isolation
await trustgraph.tenant.create({
  id: "tenant-initech",
  isolation: "namespace",  // Logical separation
});

// Complete control over tenant management

Graphlit: Managed Multi-Tenancy

Organization/Environment model:

// Graphlit's multi-tenancy model
const graphlit = new Graphlit({
  organizationId: "your-org",
  environmentId: "production",  // or "development", etc.
});

// Isolation managed by Graphlit
// Limited customization
// Predefined isolation model

Use Case Recommendations

Choose TrustGraph For:

1. Data Sovereignty Requirements

   • Healthcare (HIPAA)
   • Financial services (PCI-DSS, SOX)
   • Government (FedRAMP, ITAR)
   • EU data residency (GDPR)
   • Sensitive IP protection

2. High-Volume Applications

   • Millions of documents
   • Millions of queries/month
   • Cost optimization critical
   • Need unlimited usage

3. Custom Requirements

   • Proprietary algorithms
   • Custom graph schemas
   • Domain-specific processing
   • Integration with existing systems

4. On-Premise / Air-Gapped

   • No internet connectivity
   • Internal-only deployment
   • Legacy system integration
   • Complete isolation required

5. Open Source Preference

   • Need code transparency
   • Want to contribute
   • Avoid vendor lock-in
   • Community-driven development

Choose Graphlit For:

1. Rapid Prototyping

   • Quick proof-of-concepts
   • No infrastructure setup
   • Fast iteration
   • Demo applications

2. Low-Volume Applications

   • Small document counts
   • Limited queries
   • Usage-based costs acceptable
   • Simple use cases

3. No DevOps Capability

   • Cannot manage infrastructure
   • Want fully managed service
   • No scaling expertise
   • Prefer hands-off approach

4. Standard Requirements

   • API capabilities sufficient
   • No custom processing needed
   • Standard features adequate
   • Data sovereignty not critical

Integration & Ecosystem

TrustGraph

Open integration:

• ✅ 40+ LLM providers (OpenAI, Anthropic, Google, AWS, Azure, local models)
• ✅ Multiple graph databases (Neo4j, Cassandra, Memgraph, FalkorDB)
• ✅ Multiple vector stores (Qdrant, Pinecone, Milvus, Weaviate)
• ✅ Apache Pulsar messaging
• ✅ MCP native support
• ✅ Custom connectors possible
• ✅ Open APIs

Graphlit

Graphlit ecosystem:

• ⚠️ Supported LLM providers (via Graphlit)
• ⚠️ Managed graph store (proprietary)
• ⚠️ Managed vector store (proprietary)
• ⚠️ Graphlit API only
• ⚠️ Limited to supported integrations
• ⚠️ Feature requests required for new integrations

Migration & Portability

TrustGraph: Full Portability

Easy migration and backup:

# Export entire knowledge graph
trustgraph export --format=neo4j --output=graph_backup.cypher
trustgraph export --format=vectors --output=vectors_backup.json

# Migrate to different infrastructure
trustgraph import --source=graph_backup.cypher --target=new-cluster

# Switch graph databases
trustgraph migrate --from=neo4j --to=memgraph

# No vendor lock-in
# Your data, your control

Graphlit: Limited Portability

Vendor lock-in considerations:

// Export via API (if available)
const contents = await graphlit.exportContents();

// Migration challenges:
// - Proprietary format
// - Limited export options
// - Graph structure may not export
// - Rebuilding required on new platform
// - Vendor dependency

Conclusion

TrustGraph and Graphlit represent two different approaches to Knowledge Graph platforms:

Choose TrustGraph when you need:

• Data sovereignty and control
• On-premise or air-gapped deployment
• High-volume, cost-effective operations
• Full customization capabilities
• Open source transparency
• No vendor lock-in
• Direct database access
• Compliance with strict regulations

Choose Graphlit when you need:

• Rapid deployment without infrastructure
• Fully managed service
• Low-volume applications
• Standard API capabilities are sufficient
• No DevOps capability
• Pay-as-you-go model
• Data sovereignty is not critical

For enterprise deployments, regulated industries, high-volume applications, and custom requirements, TrustGraph's open-source, self-hosted approach provides the control, flexibility, and cost-effectiveness needed. For rapid prototyping and low-volume applications where data sovereignty is not a concern, Graphlit's managed service offers convenience.

Additional Resources

Graphlit:

• Official Website
• Documentation

TrustGraph:

• TrustGraph Website
• TrustGraph Documentation
• TrustGraph GitHub

Next Steps

• TrustGraph Documentation
• Deploy TrustGraph
• TrustGraph GitHub
• Understanding Knowledge Graphs