Organizations

Organizations can use Syft Space to create AI-powered support systems, internal knowledge bases, and customer-facing assistants from their documentation while maintaining control over what information is exposed.

Why Syft Space for organizations

Data sovereignty

Keep sensitive documentation on your infrastructure, not third-party platforms.

Controlled access

Separate internal and external knowledge bases with fine-grained access control.

Cost effective

Reduce support costs by enabling self-service with AI assistants.

Always up to date

Automatically update knowledge base as documentation changes.

Use cases

Customer support assistant

Reduce support tickets by letting customers query your documentation with AI. What to index:

Product documentation
FAQ articles
Troubleshooting guides
Video transcripts
Release notes

Example queries:

“How do I reset my password?”
“What’s the difference between Pro and Enterprise plans?”
“Why is my API returning 403 errors?”

Benefits:

24/7 automated support
Reduce support ticket volume by 40-60%
Faster resolution times
Consistent answers across all channels

Internal knowledge base

Make company knowledge instantly searchable for employees. What to index:

Internal wikis and documentation
Meeting notes and decisions
Company policies and procedures
Onboarding materials
Team playbooks

Example queries:

“What’s our PTO policy?”
“How do I submit an expense report?”
“Who approved the Q3 marketing budget?”
“What’s the process for deploying to production?”

Benefits:

Reduce time wasted searching for information
Preserve institutional knowledge
Speed up onboarding
Improve cross-team collaboration

Developer documentation assistant

Help developers find API documentation and code examples faster. What to index:

API reference documentation
SDK guides and examples
Architecture documentation
Code comments and README files
Stack Overflow-style Q&A

Example queries:

“How do I authenticate with the API?”
“Show me examples of pagination”
“What are the rate limits for the search endpoint?”

Benefits:

Improve developer experience
Reduce integration time
Fewer support questions
Better API adoption

Compliance and training

Create AI assistants for regulatory compliance and employee training. What to index:

Compliance manuals
Training materials
Standard operating procedures
Regulatory requirements
Audit checklists

Example queries:

“What are the GDPR requirements for data deletion?”
“What safety equipment is required for this procedure?”
“What’s the escalation process for security incidents?”

Benefits:

Ensure compliance with regulations
Reduce training time
Provide instant policy lookup
Track query analytics for audit trails

Getting started

Deploy Syft Space

Choose your deployment method:

Docker (recommended)
Cloud VM
Kubernetes

docker run -d \
  --name syft-space \
  --restart unless-stopped \
  -p 8080:8080 \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v syft-space-data:/data \
  -e SYFT_ADMIN_API_KEY=your-secret-key \
  ghcr.io/openmined/syft-space:latest

apiVersion: apps/v1
kind: Deployment
metadata:
  name: syft-space
spec:
  replicas: 1
  selector:
    matchLabels:
      app: syft-space
  template:
    metadata:
      labels:
        app: syft-space
    spec:
      containers:
      - name: syft-space
        image: ghcr.io/openmined/syft-space:latest
        ports:
        - containerPort: 8080
        env:
        - name: SYFT_ADMIN_API_KEY
          valueFrom:
            secretKeyRef:
              name: syft-secrets
              key: admin-api-key

Create datasets for different knowledge bases

Separate internal and external knowledge:

# Customer-facing documentation
curl -X POST http://localhost:8080/api/v1/datasets/ \
  -H "Authorization: Bearer $ADMIN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "customer-docs",
    "dtype": "local_file",
    "configuration": {
      "httpPort": 8081,
      "grpcPort": 50051,
      "collectionName": "CustomerDocs",
      "ingestionPath": "/data/docs/customer"
    }
  }'

# Internal knowledge base
curl -X POST http://localhost:8080/api/v1/datasets/ \
  -H "Authorization: Bearer $ADMIN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "internal-kb",
    "dtype": "local_file",
    "configuration": {
      "httpPort": 8082,
      "grpcPort": 50052,
      "collectionName": "InternalKB",
      "ingestionPath": "/data/docs/internal"
    }
  }'

Configure AI models

Choose models based on your needs:

Cloud models
Self-hosted models

For best accuracy and performance:

# OpenAI GPT-4 for customer support
curl -X POST http://localhost:8080/api/v1/models/ \
  -H "Authorization: Bearer $ADMIN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "gpt-4-turbo",
    "dtype": "openai",
    "configuration": {
      "api_key": "sk-your-key",
      "model": "gpt-4-turbo"
    }
  }'

For data privacy and cost control:

# vLLM server with Llama 3
# First, run vLLM:
# docker run -d --gpus all -p 8000:8000 \
#   vllm/vllm-openai --model meta-llama/Llama-3-70b

curl -X POST http://localhost:8080/api/v1/models/ \
  -H "Authorization: Bearer $ADMIN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "llama3-vllm",
    "dtype": "openai",
    "configuration": {
      "base_url": "http://vllm-server:8000/v1",
      "model": "meta-llama/Llama-3-70b",
      "api_key": "not-needed"
    }
  }'

Create endpoints with policies

Set up customer-facing and internal endpoints:

Customer support
Internal knowledge

# Create endpoint
curl -X POST http://localhost:8080/api/v1/endpoints/ \
  -H "Authorization: Bearer $ADMIN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Customer Support",
    "slug": "support",
    "dataset_id": "<customer-docs-id>",
    "model_id": "<model-id>",
    "response_type": "both"
  }'

# Add rate limiting
curl -X POST http://localhost:8080/api/v1/policies/ \
  -H "Authorization: Bearer $ADMIN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Customer Rate Limit",
    "dtype": "rate_limit",
    "configuration": {
      "limit": "50/hour",
      "scope": "user"
    },
    "endpoint_id": "<endpoint-id>"
  }'

# Create endpoint
curl -X POST http://localhost:8080/api/v1/endpoints/ \
  -H "Authorization: Bearer $ADMIN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Internal Knowledge Base",
    "slug": "internal",
    "dataset_id": "<internal-kb-id>",
    "model_id": "<model-id>",
    "response_type": "both"
  }'

# Restrict to employee emails
curl -X POST http://localhost:8080/api/v1/policies/ \
  -H "Authorization: Bearer $ADMIN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Employee Only",
    "dtype": "access",
    "configuration": {
      "allowlist": ["*@yourcompany.com"],
      "mode": "allowlist"
    },
    "endpoint_id": "<endpoint-id>"
  }'

Integrate with your applications

Embed the AI assistant in your existing tools:

Website widget
Slack bot
Discord bot

<script>
async function askSupport(question) {
  const response = await fetch(
    'https://your-syft-space.com/api/v1/endpoints/support/query',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': 'Bearer user-token'
      },
      body: JSON.stringify({
        messages: [{ role: 'user', content: question }]
      })
    }
  );
  return await response.json();
}
</script>

from slack_bolt import App
import requests

app = App(token="xoxb-your-token")

@app.message("ask")
def handle_question(message, say):
    question = message['text'].replace('ask ', '')
    
    response = requests.post(
        'http://syft-space:8080/api/v1/endpoints/internal/query',
        json={
            'messages': [{'role': 'user', 'content': question}]
        },
        headers={'Authorization': 'Bearer admin-key'}
    )
    
    say(response.json()['response'])

const { Client } = require('discord.js');
const axios = require('axios');

client.on('messageCreate', async (message) => {
  if (message.content.startsWith('!ask')) {
    const question = message.content.substring(5);
    
    const response = await axios.post(
      'http://syft-space:8080/api/v1/endpoints/support/query',
      {
        messages: [{ role: 'user', content: question }]
      },
      {
        headers: { Authorization: 'Bearer token' }
      }
    );
    
    message.reply(response.data.response);
  }
});

Architecture patterns

Multi-tenant deployment

For organizations with multiple teams or departments:

# Enable multi-tenancy
docker run -d \
  -e SYFT_ENABLE_MULTI_TENANCY=true \
  ...

Then include tenant header in requests:

curl -H "X-Tenant-Name: engineering" ...
curl -H "X-Tenant-Name: customer-success" ...

Hybrid deployment

Combine cloud and self-hosted components:

Syft Space: Self-hosted for data control
Vector DB: Weaviate Cloud for scalability
AI Model: OpenAI API for performance, with local fallback

High availability

For mission-critical applications:

# docker-compose.yml
version: '3.8'
services:
  syft-space:
    image: ghcr.io/openmined/syft-space:latest
    deploy:
      replicas: 3
      restart_policy:
        condition: on-failure
    
  nginx:
    image: nginx
    depends_on:
      - syft-space
    # Load balancer configuration

Best practices

Documentation organization

Structure by user journey

Organize documentation to match how users find information:

Getting started guides
Feature documentation
Troubleshooting
API reference
FAQs

Keep documentation up to date

Set up automatic ingestion:

Point ingestion path to your docs folder
Syft Space watches for changes
New docs are automatically indexed
Old content is updated as files change

Include metadata and context

Help AI provide better answers:

Add frontmatter with titles, descriptions, tags
Include last updated date
Link related articles
Specify target audience (beginner, advanced, etc.)

Security and compliance

Data residency

Deploy Syft Space in your required geographic region for compliance.

Access control

Use policies to restrict access by email domain, IP, or custom rules.

Audit logging

Enable accounting policies to track all queries and responses.

Data retention

Configure how long query logs are stored for compliance requirements.

Performance optimization

Choose the right model

Customer support: GPT-4 Turbo (best quality)
Internal docs: GPT-3.5 or Llama 3 (cost-effective)
Developer docs: Claude (best for code)

Optimize retrieval

Adjust similarity_threshold (0.7-0.8 for most uses)
Set appropriate limit (5-10 documents)
Use metadata filters to narrow searches

Cache common queries

Implement a cache layer for frequently asked questions:

cache = {}

def query_with_cache(question):
    if question in cache:
        return cache[question]
    
    result = query_syft_space(question)
    cache[question] = result
    return result

Monitor and iterate

Track metrics:

Query response time
User satisfaction ratings
Most common questions
Failed queries

Use analytics to improve documentation and tune the system.

Example: SaaS company

Company: Mid-size B2B SaaS with 500 customers Setup:

Customer documentation: 300 articles
API documentation: 50 endpoints
Internal wiki: 1,000+ pages
3 endpoints: Customer Support, Developer Docs, Internal KB

Results:

55% reduction in support tickets
3-hour average reduction in resolution time
90% customer satisfaction with AI support
$50,000/year savings in support costs
70% of developer questions answered without human support

Implementation:

Deployment: AWS EC2 (t3.large)
Vector DB: ChromaDB (self-hosted)
AI Model: GPT-4 Turbo (customer), GPT-3.5 (internal)
Rate limits: 100 queries/day per user
Access: Email domain restriction for internal KB

Integration examples

Zendesk integration

from zendesk_api import Zendesk
import requests

zendesk = Zendesk(subdomain='yourcompany', email='...', token='...')

def auto_suggest_response(ticket_id):
    ticket = zendesk.tickets.show(id=ticket_id)
    
    # Query Syft Space
    response = requests.post(
        'http://syft-space:8080/api/v1/endpoints/support/query',
        json={'messages': [{'role': 'user', 'content': ticket.description}]},
        headers={'Authorization': 'Bearer token'}
    )
    
    # Add AI suggestion as internal note
    zendesk.tickets.update(
        id=ticket_id,
        comment={'body': f"AI Suggestion:\n{response.json()['response']}", 'public': False}
    )

Intercom chatbot

const { Client } = require('intercom-client');
const axios = require('axios');

const intercom = new Client({ token: 'your-token' });

intercom.on('conversation.user.created', async (event) => {
  const message = event.data.conversation_parts[0].body;
  
  // Query Syft Space
  const response = await axios.post(
    'http://syft-space:8080/api/v1/endpoints/support/query',
    { messages: [{ role: 'user', content: message }] },
    { headers: { Authorization: 'Bearer token' } }
  );
  
  // Reply in Intercom
  intercom.conversations.reply({
    id: event.data.conversation_id,
    type: 'admin',
    message_type: 'comment',
    body: response.data.response
  });
});

Learn more

Installation

Production deployment guide

Datasets

Managing documentation sources

Policies

Access control and rate limiting

API reference

Complete API documentation

Need help with enterprise deployment? Contact us at GitHub Discussions.

Community

Use Cases

Why Syft Space for organizations

Data sovereignty

Controlled access

Cost effective

Always up to date

Use cases

Customer support assistant

Internal knowledge base

Developer documentation assistant

Compliance and training

Getting started

Architecture patterns

Multi-tenant deployment

Hybrid deployment

High availability

Best practices

Documentation organization

Security and compliance

Data residency

Access control

Audit logging

Data retention

Performance optimization

Example: SaaS company

Integration examples

Zendesk integration

Intercom chatbot

Learn more

Installation

Datasets

Policies

API reference

Build docs developers (and LLMs) love

Community

Use Cases

​Why Syft Space for organizations

Data sovereignty

Controlled access

Cost effective

Always up to date

​Use cases

​Customer support assistant

​Internal knowledge base

​Developer documentation assistant

​Compliance and training

​Getting started

​Architecture patterns

​Multi-tenant deployment

​Hybrid deployment

​High availability

​Best practices

​Documentation organization

​Security and compliance

Data residency

Access control

Audit logging

Data retention

​Performance optimization

​Example: SaaS company

​Integration examples

​Zendesk integration

​Intercom chatbot

​Learn more

Installation

Datasets

Policies

API reference

Build docs developers (and LLMs) love

Why Syft Space for organizations

Use cases

Customer support assistant

Internal knowledge base

Developer documentation assistant

Compliance and training

Getting started

Architecture patterns

Multi-tenant deployment

Hybrid deployment

High availability

Best practices

Documentation organization

Security and compliance

Performance optimization

Example: SaaS company

Integration examples

Zendesk integration

Intercom chatbot

Learn more