TrustGraph vs Neoclouds

TrustGraph and Neoclouds both enable building intelligent applications, but they differ fundamentally in their approach: Knowledge Graph-based reasoning versus document-centric AI processing.

At a Glance

Core Philosophy

TrustGraph: Knowledge Graph Foundation

TrustGraph builds structured, queryable knowledge:

// Knowledge Graph as the foundation
import { TrustGraph } from "@trustgraph/sdk";

const trustgraph = new TrustGraph({
  endpoint: "https://your-deployment.com",
});

// Ingest with graph-first approach
await trustgraph.ingest({
  sources: ["documents/", "databases/", "apis/"],
  graphConfig: {
    extractEntities: true,
    buildRelationships: true,
    ontology: "domain-schema.ttl",
    linkingStrategy: "semantic",
  },
});

// Query with relationship awareness
const result = await trustgraph.query({
  query: "How does company A's acquisition of startup B affect market C?",
  strategy: "graph-rag",
  reasoning: "multi-hop",
  graphDepth: 3,
});

// Returns structured knowledge
{
  entities: [
    { id: "company_a", type: "Company", name: "Company A" },
    { id: "startup_b", type: "Startup", name: "Startup B" },
    { id: "market_c", type: "Market", name: "Market C" }
  ],
  relationships: [
    { from: "company_a", type: "acquired", to: "startup_b", date: "2024-01-15" },
    { from: "startup_b", type: "operates_in", to: "market_c" },
    { from: "company_a", type: "expands_to", to: "market_c", inferred: true }
  ],
  reasoning_paths: [
    ["company_a", "acquired", "startup_b", "operates_in", "market_c"]
  ]
}

Key characteristics:

• Relationships are first-class
• Multi-hop reasoning native
• Structured, queryable knowledge
• Graph-based inference

Neoclouds: Document Intelligence Platform

Neoclouds focuses on document processing and AI services:

from neoclouds import Client

# Initialize Neoclouds client
client = Client(api_key="your-api-key")

# Document-centric processing
document = client.documents.upload("invoice.pdf")

# Extract structured data from document
result = client.documents.extract(
    document_id=document.id,
    template="invoice",  # Predefined or custom template
)

# Document understanding
classification = client.documents.classify(document.id)
entities = client.documents.extract_entities(document.id)

# Use AI services
embedding = client.embeddings.create(text="query text")
search_results = client.search.query(
    query="find similar documents",
    filters={"type": "invoice"}
)

# Generate with LLM
response = client.completions.create(
    prompt="Summarize this invoice",
    context=document.text
)

# Returns document-focused results
{
  "document_type": "invoice",
  "extracted_fields": {
    "invoice_number": "INV-12345",
    "amount": "$1,234.56",
    "date": "2024-01-15"
  },
  "entities": ["Company A", "John Smith"],
  "summary": "..."
}

Key characteristics:

• Document processing focus
• OCR and layout analysis
• Structured data extraction
• AI service composition

Primary Strengths

TrustGraph: Relationship-Based Reasoning

Multi-hop graph queries:

// Complex relationship queries
const analysis = await trustgraph.query({
  cypher: `
    // Find indirect influences
    MATCH path = (trend:Trend)-[*1..4]->(company:Company)
    WHERE trend.name = 'AI Adoption'
      AND company.sector = 'Healthcare'
    RETURN path,
           length(path) as hops,
           relationships(path) as relationship_chain
    ORDER BY hops
  `,
});

// Automatic inference
const inferences = await trustgraph.reason({
  query: "If company X partners with company Y, how might this affect competitors?",
  strategy: "graph-inference",
  maxDepth: 3,
});

// Returns relationship chains with reasoning
{
  direct_effects: [
    { entity: "competitor_a", effect: "market_share_loss", confidence: 0.85 }
  ],
  indirect_effects: [
    {
      path: ["company_x", "partners_with", "company_y", "competes_with", "competitor_a"],
      effect: "increased_pressure",
      confidence: 0.72
    }
  ],
  market_implications: [...]
}

Temporal relationship tracking:

// Time-aware queries
const evolution = await trustgraph.query({
  temporal: true,
  query: "How has the relationship between entity A and B evolved over time?",
  timeRange: {
    start: "2020-01-01",
    end: "2024-12-31",
  },
});

// Returns temporal graph
{
  snapshots: [
    { date: "2020-01-01", relationship: "competitor" },
    { date: "2022-06-15", relationship: "partner" },
    { date: "2024-01-10", relationship: "acquired_by" }
  ],
  trend_analysis: "evolved from competition to acquisition"
}

Neoclouds: Document Understanding

Advanced document processing:

# OCR and layout analysis
document = client.documents.upload("complex_report.pdf")

# Extract layout structure
layout = client.documents.analyze_layout(document.id)
{
  "pages": 45,
  "sections": [
    {"type": "title", "text": "Annual Report", "page": 1},
    {"type": "table", "rows": 20, "cols": 5, "page": 3},
    {"type": "chart", "chart_type": "bar", "page": 5}
  ],
  "tables": [...],
  "figures": [...]
}

# Classify documents
classification = client.documents.classify(
    document.id,
    categories=["invoice", "contract", "report", "email"]
)

# Extract using templates
extraction = client.documents.extract(
    document.id,
    template={
        "fields": [
            {"name": "total_amount", "type": "currency"},
            {"name": "date", "type": "date"},
            {"name": "parties", "type": "list"}
        ]
    }
)

Document-centric AI:

# Search across documents
results = client.search.semantic_search(
    query="contracts with Company X",
    document_types=["contract"],
    date_range={"start": "2024-01-01", "end": "2024-12-31"}
)

# Generate from documents
summary = client.completions.create(
    prompt="Create executive summary",
    documents=[doc1.id, doc2.id, doc3.id],
    style="professional"
)

# Document Q&A
answer = client.qa.ask(
    question="What are the payment terms?",
    document_id=document.id
)

Knowledge Representation

TrustGraph: Structured Graph

Explicit entities and relationships:

// Graph structure
{
  nodes: [
    {
      id: "person_1",
      type: "Person",
      properties: {
        name: "Jane Smith",
        role: "CEO",
        company: "company_1"
      }
    },
    {
      id: "company_1",
      type: "Company",
      properties: {
        name: "TechCorp",
        industry: "Software",
        founded: "2010"
      }
    }
  ],
  edges: [
    {
      from: "person_1",
      to: "company_1",
      type: "leads",
      properties: {
        since: "2020",
        confidence: 0.95
      }
    }
  ]
}

// Queryable with graph languages
await trustgraph.query({
  cypher: "MATCH (p:Person)-[:leads]->(c:Company) WHERE c.industry = 'Software' RETURN p, c"
});

Ontology-driven:

// Define domain ontology
await trustgraph.schema.define({
  ontology: `
    @prefix ex: <http://example.com/ontology#> .

    ex:Person a rdfs:Class .
    ex:Company a rdfs:Class .
    ex:leads a rdf:Property ;
      rdfs:domain ex:Person ;
      rdfs:range ex:Company .
    ex:competes_with a rdf:Property ;
      rdfs:domain ex:Company ;
      rdfs:range ex:Company ;
      ex:symmetric true .
  `
});

// Schema enforces consistency
// Enables inference

Neoclouds: Document-Centric

Document metadata and chunks:

# Document representation
{
  "document_id": "doc_123",
  "metadata": {
    "filename": "report.pdf",
    "type": "financial_report",
    "date": "2024-01-15",
    "pages": 50
  },
  "chunks": [
    {
      "id": "chunk_1",
      "text": "Company TechCorp reported...",
      "page": 1,
      "embedding": [0.23, -0.15, ...],
      "metadata": {
        "section": "executive_summary"
      }
    }
  ],
  "extracted_entities": [
    {"text": "TechCorp", "type": "ORGANIZATION"},
    {"text": "Jane Smith", "type": "PERSON"}
  ]
}

# Relationships implicit in text, not structured
# No explicit graph of entity relationships
# Query via embeddings, not graph traversal

Use Case Comparison

Where TrustGraph Excels

Complex Relationship Analysis:

// Multi-hop reasoning
const analysis = await trustgraph.query({
  query: "Find all companies connected to Company X within 3 degrees",
  graphDepth: 3,
  relationshipTypes: ["invests_in", "partners_with", "acquired"],
});

// Investment network analysis
const network = await trustgraph.analyze({
  algorithm: "network_analysis",
  startNode: "venture_capital_firm_a",
  includeIndirect: true,
});

Knowledge Base Integration:

// Unified knowledge from multiple sources
await trustgraph.ingest({
  sources: [
    "databases/crm",
    "documents/contracts",
    "apis/market_data",
    "web/news_feeds"
  ],
  // Builds unified Knowledge Graph
  // All sources connected via relationships
});

// Query across all sources
const insights = await trustgraph.query({
  query: "Connect customer behavior (CRM) to market trends (news) via product relationships",
  crossSource: true,
});

Inference and Reasoning:

// Infer new knowledge
const inferences = await trustgraph.reason({
  rules: [
    "IF company A acquires company B AND company B partners with company C THEN company A has indirect relationship with company C",
  ],
  applyInferences: true,
});

Where Neoclouds Excels

Document Processing Pipelines:

# Complex document workflows
pipeline = client.pipelines.create([
    {"stage": "ocr", "config": {"language": "en"}},
    {"stage": "layout_analysis"},
    {"stage": "table_extraction"},
    {"stage": "entity_extraction"},
    {"stage": "classification"},
    {"stage": "data_validation"}
])

# Process batch of documents
results = client.pipelines.run(
    pipeline_id=pipeline.id,
    documents=[doc1, doc2, doc3]
)

Document Classification & Extraction:

# Intelligent document processing
classification = client.documents.classify(
    document_id,
    model="custom_classifier"
)

if classification.type == "invoice":
    extraction = client.documents.extract(
        document_id,
        template="invoice_template"
    )
    # Returns structured fields
elif classification.type == "contract":
    extraction = client.documents.extract(
        document_id,
        template="contract_template"
    )

Document-Specific AI:

# Document comparison
comparison = client.documents.compare(
    document_a_id,
    document_b_id,
    aspects=["clauses", "terms", "obligations"]
)

# Document generation
new_doc = client.documents.generate(
    template="contract_template",
    data={"party_a": "Company X", "party_b": "Company Y"},
    style="legal"
)

Integration & Deployment

TrustGraph: Unified Platform

Complete platform deployment:

# Deploy entire stack
docker compose -f trustgraph_system.yaml up -d

# Includes:
# - Knowledge Graph database
# - Vector store
# - Agent orchestration
# - API gateway
# - Monitoring

// Single SDK for everything
const trustgraph = new TrustGraph({
  endpoint: "https://your-deployment.com"
});

// All capabilities through one interface
await trustgraph.ingest({...});
await trustgraph.query({...});
await trustgraph.reason({...});
await trustgraph.agents.create({...});

Neoclouds: Modular Services

Service-based architecture:

from neoclouds import (
    DocumentClient,
    SearchClient,
    CompletionClient,
    EmbeddingClient
)

# Initialize multiple clients
docs = DocumentClient(api_key="...")
search = SearchClient(api_key="...")
completions = CompletionClient(api_key="...")
embeddings = EmbeddingClient(api_key="...")

# Coordinate services
document = docs.upload("file.pdf")
embedding = embeddings.create(document.text)
results = search.query(embedding)
summary = completions.create(context=results)

Pricing & Cost

TrustGraph

Open Source:
- Free software
- Self-hosted infrastructure costs
- Optional enterprise support

Typical Monthly Cost (1M docs, 10M queries):
- Infrastructure: $3,000-5,000
- LLM APIs: $2,000-4,000
- Total: $5,000-9,000

Neoclouds

Usage-Based (typical):
- Document processing: Per page/document
- API calls: Per request
- Storage: Per GB
- AI services: Per token/call

Typical Monthly Cost (1M docs, 10M queries):
- Document processing: $3,000-8,000
- API calls: $2,000-5,000
- Storage: $500-1,000
- Total: $5,500-14,000

Note: Varies significantly based on usage

Use Case Recommendations

Choose TrustGraph For:

1. Complex Knowledge Management

   • Building enterprise knowledge bases
   • Multi-hop reasoning required
   • Relationship understanding critical
   • Knowledge Graph is core requirement

2. Integration of Multiple Data Sources

   • Combining databases, documents, APIs
   • Need unified knowledge representation
   • Cross-source reasoning
   • Knowledge synthesis

3. Relationship-Driven Applications

   • Social network analysis
   • Supply chain mapping
   • Investment network tracking
   • Research knowledge graphs

4. Custom Reasoning Requirements

   • Domain-specific inference rules
   • Temporal reasoning
   • Probabilistic reasoning
   • Custom graph algorithms

5. Data Sovereignty

   • On-premise deployment
   • Complete control over data
   • Open source requirements
   • No vendor lock-in

Choose Neoclouds For:

1. Document-Heavy Workflows

   • Processing thousands of documents
   • OCR and layout analysis critical
   • Document classification needed
   • Structured data extraction

2. Document Intelligence Applications

   • Invoice processing
   • Contract analysis
   • Form understanding
   • Document generation

3. Rapid AI Integration

   • Quick AI service access
   • Pre-built document models
   • Managed infrastructure preferred
   • API-first approach

4. Document-Centric RAG

   • Q&A over documents
   • Document search
   • Document summarization
   • Simple retrieval needs

Complementary Use

Using both together:

# Use Neoclouds for document processing
from neoclouds import Client as NeoClient
neo = NeoClient(api_key="...")

# Process documents
documents = neo.documents.batch_upload(["doc1.pdf", "doc2.pdf"])
extracted_data = [neo.documents.extract(d.id) for d in documents]

# Extract entities and relationships
entities = []
relationships = []
for data in extracted_data:
    entities.extend(extract_entities_from_data(data))
    relationships.extend(extract_relationships_from_data(data))

# Build Knowledge Graph with TrustGraph
from trustgraph import TrustGraph
tg = TrustGraph(endpoint="...")

# Ingest extracted knowledge
tg.ingest_entities(entities)
tg.ingest_relationships(relationships)

# Use TrustGraph for reasoning
analysis = tg.query({
    "query": "Analyze relationships across all processed documents",
    "strategy": "graph-rag",
    "reasoning": "multi-hop"
})

Conclusion

TrustGraph and Neoclouds serve complementary needs:

Choose TrustGraph when you need:

• Knowledge Graph-based reasoning
• Multi-hop relationship queries
• Unified knowledge representation
• Complex inference and reasoning
• Open source platform
• Data sovereignty
• Integration of multiple sources
• Graph-first architecture

Choose Neoclouds when you need:

• Advanced document processing
• OCR and layout analysis
• Document classification
• Structured data extraction
• Document-centric AI services
• Managed document intelligence
• Rapid API integration

For knowledge-intensive applications requiring relationship understanding and complex reasoning, TrustGraph's Knowledge Graph foundation is essential. For document processing pipelines and document intelligence, Neoclouds provides excellent capabilities.

Many organizations benefit from using both: Neoclouds for document processing and extraction, TrustGraph for building Knowledge Graphs and performing complex reasoning over the extracted knowledge.

Additional Resources

Neoclouds:

• Official Website
• Documentation

TrustGraph:

• TrustGraph Website
• TrustGraph Documentation
• TrustGraph GitHub

Next Steps

• TrustGraph Documentation
• Understanding Knowledge Graphs
• TrustGraph vs LangChain
• Building Knowledge Graph Applications