Knowledge API

// Sync customer data from CRM
const customer = await crm.getCustomer(id);
await ask0.knowledge.ingest({
  type: 'customer',
  id: customer.id,
  content: {
    name: customer.name,
    plan: customer.plan,
    history: customer.supportHistory,
    preferences: customer.preferences
  }
});

// Sync product catalog from database
const products = await db.query('SELECT * FROM products');
for (const product of products) {
  await ask0.knowledge.ingest({
    type: 'product',
    id: product.sku,
    content: {
      name: product.name,
      description: product.description,
      price: product.price,
      features: product.features
    }
  });
}

// Auto-generate from OpenAPI spec
const spec = await fetch('/openapi.json');
const endpoints = spec.paths;

for (const [path, methods] of Object.entries(endpoints)) {
  await ask0.knowledge.ingest({
    type: 'api_endpoint',
    id: path,
    content: {
      path: path,
      methods: methods,
      parameters: methods.parameters,
      responses: methods.responses
    }
  });
}

// Update knowledge on events
eventBus.on('product.updated', async (product) => {
  await ask0.knowledge.update({
    type: 'product',
    id: product.id,
    content: product
  });
});

eventBus.on('article.published', async (article) => {
  await ask0.knowledge.ingest({
    type: 'article',
    id: article.id,
    content: article
  });
});

POST /api/knowledge/ingest
PUT /api/knowledge/{id}
DELETE /api/knowledge/{id}
PATCH /api/knowledge/{id}

// Bulk ingestion
await ask0.knowledge.batchIngest([
  { type: 'faq', id: '1', content: {...} },
  { type: 'faq', id: '2', content: {...} },
  // ... up to 1000 items
]);

// Bulk updates
await ask0.knowledge.batchUpdate([...]);

// Bulk delete
await ask0.knowledge.batchDelete(['id1', 'id2', 'id3']);

// Stream updates
const stream = ask0.knowledge.stream();

stream.on('data', (chunk) => {
  // Process incoming knowledge chunk
});

// Push updates via stream
stream.write({
  type: 'log',
  content: 'System event occurred...'
});

Webhook Events:
  - knowledge.ingested
  - knowledge.updated
  - knowledge.deleted
  - knowledge.indexed
  - knowledge.failed

Configuration:
  URL: https://your-app.com/webhook
  Secret: webhook_secret
  Events: [knowledge.ingested, knowledge.failed]
  Retry: 3 times with exponential backoff

Structured Types:
  - FAQ: Question-answer pairs
  - Product: Product information
  - Article: Long-form content
  - API: Endpoint documentation
  - Person: Team/contact information
  - Event: Time-based information

Custom Types:
  - Define your own schemas
  - Validation rules
  - Custom processing
  - Type-specific search

// Rich metadata
await ask0.knowledge.ingest({
  type: 'document',
  id: 'doc-123',
  content: 'Document content...',
  metadata: {
    author: 'John Doe',
    category: 'Technical',
    tags: ['api', 'integration'],
    version: '2.0',
    language: 'en',
    expires: '2024-12-31',
    access_level: 'public',
    related: ['doc-124', 'doc-125'],
    custom: {
      department: 'Engineering',
      product_line: 'Core API'
    }
  }
});

// Search ingested knowledge
const results = await ask0.knowledge.search({
  query: 'payment processing',
  filters: {
    type: 'documentation',
    category: 'api',
    tags: ['payment'],
    updated_after: '2024-01-01'
  },
  limit: 20
});

// Get specific knowledge
const item = await ask0.knowledge.get('doc-123');

// List by criteria
const items = await ask0.knowledge.list({
  type: 'faq',
  category: 'billing',
  sort: 'updated_at',
  order: 'desc'
});

// Version management
await ask0.knowledge.ingest({
  id: 'doc-123',
  content: 'Updated content',
  version: {
    number: '2.1',
    changelog: 'Fixed typos and added examples',
    previous: '2.0'
  }
});

// Retrieve specific version
const v1 = await ask0.knowledge.getVersion('doc-123', '1.0');

// List versions
const versions = await ask0.knowledge.listVersions('doc-123');

// Get ingestion statistics
const stats = await ask0.knowledge.stats();
console.log(stats);
// {
//   total: 10000,
//   by_type: { faq: 3000, product: 2000, ... },
//   last_24h: 234,
//   failed: 12,
//   processing: 5
// }

// Monitor ingestion health
const health = await ask0.knowledge.health();
// {
//   status: 'healthy',
//   queue_size: 45,
//   processing_rate: '100/min',
//   error_rate: 0.01
// }

// Sync Zendesk articles
const articles = await zendesk.articles.list();
for (const article of articles) {
  await ask0.knowledge.ingest({
    type: 'support_article',
    id: `zendesk-${article.id}`,
    content: article,
    metadata: {
      source: 'zendesk',
      url: article.url,
      category: article.section
    }
  });
}

// Sync product catalog
shopify.products.on('update', async (product) => {
  await ask0.knowledge.update({
    type: 'product',
    id: `shopify-${product.id}`,
    content: {
      name: product.title,
      description: product.description,
      price: product.price,
      variants: product.variants,
      inventory: product.inventory
    }
  });
});

Authorization: Bearer YOUR_API_KEY
X-Project-ID: YOUR_PROJECT_ID

Rate Limits:
  Free Tier: 100 requests/hour
  Pro Tier: 1,000 requests/hour
  Enterprise: Unlimited

Ingestion Limits:
  Max Size per Item: 1 MB
  Batch Size: 1,000 items
  Concurrent Requests: 10

// JavaScript/TypeScript
npm install @ask0/knowledge-api

// Python
pip install ask0-knowledge

// Go
go get github.com/ask0/knowledge-api-go

// Ruby
gem install ask0-knowledge

ask0 knowledge ingest --file data.json --type product

ask0 knowledge sync --source postgres://... --query "SELECT * FROM faqs"

ask0 knowledge status

ask0 knowledge search "payment processing"

ask0 migrate algolia --app-id XXX --api-key YYY

ask0 migrate elasticsearch --host localhost:9200 --index knowledge

ask0 migrate pinecone --api-key ZZZ --index my-index