SDK Integration Guide

Official SDKs for integrating CODITECT DMS into your applications.

---

Python SDK

Installation

pip install coditect-dms

Quick Start

from coditect import DMSClient

# Initialize client
client = DMSClient(api_key="dms_prod_sk_...")

# Search documents
results = client.search("How do I implement authentication?")
for result in results:
    print(f"{result.score:.2f}: {result.document_title}")
    print(f"  {result.content[:200]}")

# Upload document
doc = client.documents.upload("./my-document.md")
print(f"Uploaded: {doc.id} - Status: {doc.status}")

# Wait for processing
doc = client.documents.wait_for_processing(doc.id, timeout=120)
print(f"Processing complete: {doc.chunk_count} chunks")

Detailed Usage

Configuration

from coditect import DMSClient, Config

# Full configuration
config = Config(
    api_key="dms_prod_sk_...",
    base_url="https://dms-api.coditect.ai/api/v1",
    timeout=30,
    max_retries=3,
    retry_backoff=1.5,
)

client = DMSClient(config=config)

# Or use environment variables
# CODITECT_API_KEY, CODITECT_API_URL
client = DMSClient()

Search Operations

from coditect import SearchMode

# Basic search
results = client.search("authentication")

# Advanced search
results = client.search(
    query="How do I implement JWT authentication?",
    mode=SearchMode.HYBRID,
    top_k=20,
    min_score=0.4,
    include_content=True,
    expand_context=True,
    context_chunks=2,
)

# Iterate results
for result in results:
    print(f"Score: {result.score}")
    print(f"Document: {result.document_title}")
    print(f"Section: {result.section_title}")
    print(f"Content: {result.content}")
    print(f"Context Before: {result.context_before}")
    print(f"Context After: {result.context_after}")

GraphRAG Traversal

from coditect import RelationshipType

# Traverse from a chunk
context = client.graphrag.traverse(
    seed_chunk_id="550e8400-e29b-41d4-a716-446655440001",
    max_depth=2,
    max_nodes=15,
    relationship_types=[RelationshipType.SEQUENTIAL, RelationshipType.SEMANTIC],
    min_weight=0.5,
)

print(f"Seed: {context.seed_chunk.content[:100]}")
print(f"Related: {len(context.related_chunks)} chunks")
print(f"Relationships: {len(context.relationships)}")

for chunk in context.related_chunks:
    print(f"  - {chunk.section_title}: {chunk.content[:50]}...")

Document Management

# List documents
docs = client.documents.list(
    page=1,
    page_size=50,
    status="completed",
    document_type="guide",
)

# Upload from file
doc = client.documents.upload("./security-guide.md")

# Upload with metadata
doc = client.documents.create(
    filename="architecture.md",
    content="# Architecture\n\n...",
    document_type="adr",
    keywords=["architecture", "design"],
    tags=["v2"],
)

# Get document
doc = client.documents.get("550e8400-e29b-41d4-a716-446655440000")

# Update metadata
doc = client.documents.update(
    doc_id=doc.id,
    title="Updated Title",
    summary="New summary",
)

# Get chunks
chunks = client.documents.get_chunks(doc.id)
for chunk in chunks:
    print(f"Chunk {chunk.sequence_num}: {chunk.token_count} tokens")

# Delete document
client.documents.delete(doc.id)

Analytics

from datetime import datetime, timedelta
from coditect import MetricType, TimeGranularity

# Get dashboard metrics
dashboard = client.analytics.dashboard()
print(f"Total documents: {dashboard.document_metrics.total_documents}")
print(f"Total searches: {dashboard.search_metrics.total_searches}")

# Query time-series metrics
metrics = client.analytics.query_metrics(
    metric_types=[MetricType.SEARCHES_PERFORMED, MetricType.DOCUMENTS_UPLOADED],
    start_time=datetime.now() - timedelta(days=7),
    end_time=datetime.now(),
    granularity=TimeGranularity.DAY,
)

for series in metrics.series:
    print(f"{series.label}: {series.total} total")

# Get usage for billing
usage = client.analytics.usage()
print(f"Documents: {usage.documents_uploaded}")
print(f"Searches: {usage.searches_performed}")
print(f"Cost: ${usage.embedding_cost_usd:.2f}")

Error Handling

from coditect import (
    DMSError,
    AuthenticationError,
    RateLimitError,
    NotFoundError,
    ValidationError,
)

try:
    results = client.search("query")
except AuthenticationError:
    print("Invalid API key")
except RateLimitError as e:
    print(f"Rate limited. Retry after {e.retry_after} seconds")
except NotFoundError:
    print("Resource not found")
except ValidationError as e:
    print(f"Validation error: {e.errors}")
except DMSError as e:
    print(f"API error: {e.message}")

Async Support

import asyncio
from coditect import AsyncDMSClient

async def main():
    client = AsyncDMSClient(api_key="dms_prod_sk_...")

    # Concurrent searches
    tasks = [
        client.search("authentication"),
        client.search("authorization"),
        client.search("security"),
    ]
    results = await asyncio.gather(*tasks)

    for result in results:
        print(f"Found {len(result)} results")

    await client.close()

asyncio.run(main())

---

TypeScript/JavaScript SDK

Installation

npm install @coditect/dms-client
# or
yarn add @coditect/dms-client

Quick Start

import { DMSClient } from '@coditect/dms-client';

// Initialize client
const client = new DMSClient({
  apiKey: 'dms_prod_sk_...',
});

// Search documents
const results = await client.search({
  query: 'How do I implement authentication?',
  mode: 'hybrid',
  topK: 10,
});

results.forEach((result) => {
  console.log(`${result.score.toFixed(2)}: ${result.documentTitle}`);
  console.log(`  ${result.content.slice(0, 200)}`);
});

// Upload document
const doc = await client.documents.upload('./my-document.md');
console.log(`Uploaded: ${doc.id} - Status: ${doc.status}`);

Detailed Usage

Configuration

import { DMSClient, Config } from '@coditect/dms-client';

const config: Config = {
  apiKey: process.env.CODITECT_API_KEY!,
  baseUrl: 'https://dms-api.coditect.ai/api/v1',
  timeout: 30000,
  retries: 3,
};

const client = new DMSClient(config);

Search Operations

import { SearchMode } from '@coditect/dms-client';

// Basic search
const results = await client.search({ query: 'authentication' });

// Advanced search
const results = await client.search({
  query: 'How do I implement JWT authentication?',
  mode: SearchMode.Hybrid,
  topK: 20,
  minScore: 0.4,
  includeContent: true,
  expandContext: true,
  contextChunks: 2,
});

// Process results
for (const result of results) {
  console.log(`Score: ${result.score}`);
  console.log(`Document: ${result.documentTitle}`);
  console.log(`Section: ${result.sectionTitle}`);
  console.log(`Content: ${result.content}`);
}

GraphRAG Traversal

import { RelationshipType } from '@coditect/dms-client';

const context = await client.graphrag.traverse({
  seedChunkId: '550e8400-e29b-41d4-a716-446655440001',
  maxDepth: 2,
  maxNodes: 15,
  relationshipTypes: [RelationshipType.Sequential, RelationshipType.Semantic],
  minWeight: 0.5,
});

console.log(`Seed: ${context.seedChunk.content.slice(0, 100)}`);
console.log(`Related: ${context.relatedChunks.length} chunks`);
console.log(`Relationships: ${context.relationships.length}`);

Document Management

// List documents
const docs = await client.documents.list({
  page: 1,
  pageSize: 50,
  status: 'completed',
  documentType: 'guide',
});

// Upload file (Node.js)
import fs from 'fs';
const file = fs.readFileSync('./security-guide.md');
const doc = await client.documents.upload(file, 'security-guide.md');

// Upload with metadata
const doc = await client.documents.create({
  filename: 'architecture.md',
  content: '# Architecture\n\n...',
  documentType: 'adr',
  keywords: ['architecture', 'design'],
  tags: ['v2'],
});

// Get document
const doc = await client.documents.get('550e8400-...');

// Update metadata
const updated = await client.documents.update(doc.id, {
  title: 'Updated Title',
  summary: 'New summary',
});

// Delete document
await client.documents.delete(doc.id);

Analytics

import { MetricType, TimeGranularity } from '@coditect/dms-client';

// Get dashboard metrics
const dashboard = await client.analytics.dashboard();
console.log(`Total documents: ${dashboard.documentMetrics.totalDocuments}`);

// Query time-series metrics
const metrics = await client.analytics.queryMetrics({
  metricTypes: [MetricType.SearchesPerformed, MetricType.DocumentsUploaded],
  startTime: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
  endTime: new Date(),
  granularity: TimeGranularity.Day,
});

for (const series of metrics.series) {
  console.log(`${series.label}: ${series.total} total`);
}

Error Handling

import {
  DMSError,
  AuthenticationError,
  RateLimitError,
  NotFoundError,
  ValidationError,
} from '@coditect/dms-client';

try {
  const results = await client.search({ query: 'test' });
} catch (error) {
  if (error instanceof AuthenticationError) {
    console.log('Invalid API key');
  } else if (error instanceof RateLimitError) {
    console.log(`Rate limited. Retry after ${error.retryAfter} seconds`);
  } else if (error instanceof NotFoundError) {
    console.log('Resource not found');
  } else if (error instanceof ValidationError) {
    console.log(`Validation error: ${JSON.stringify(error.errors)}`);
  } else if (error instanceof DMSError) {
    console.log(`API error: ${error.message}`);
  }
}

React Integration

import { useDMS, DMSProvider } from '@coditect/dms-react';

// Wrap your app
function App() {
  return (
    <DMSProvider apiKey={process.env.REACT_APP_CODITECT_API_KEY!}>
      <SearchComponent />
    </DMSProvider>
  );
}

// Use in components
function SearchComponent() {
  const { search, isLoading, results, error } = useDMS();

  const handleSearch = async (query: string) => {
    await search({ query, mode: 'hybrid', topK: 10 });
  };

  return (
    <div>
      <input
        type="text"
        onChange={(e) => handleSearch(e.target.value)}
        placeholder="Search documents..."
      />
      {isLoading && <p>Searching...</p>}
      {error && <p>Error: {error.message}</p>}
      {results?.map((result) => (
        <div key={result.chunkId}>
          <h3>{result.documentTitle}</h3>
          <p>{result.content}</p>
        </div>
      ))}
    </div>
  );
}

---

Go SDK

Installation

go get github.com/coditect-ai/dms-go

Quick Start

package main

import (
    "context"
    "fmt"
    "log"

    dms "github.com/coditect-ai/dms-go"
)

func main() {
    // Initialize client
    client := dms.NewClient(dms.Config{
        APIKey: "dms_prod_sk_...",
    })

    // Search documents
    results, err := client.Search(context.Background(), &dms.SearchRequest{
        Query: "How do I implement authentication?",
        Mode:  dms.SearchModeHybrid,
        TopK:  10,
    })
    if err != nil {
        log.Fatal(err)
    }

    for _, result := range results.Results {
        fmt.Printf("%.2f: %s\n", result.Score, result.DocumentTitle)
        fmt.Printf("  %s\n", result.Content[:200])
    }
}

Detailed Usage

package main

import (
    "context"
    "fmt"
    "os"
    "time"

    dms "github.com/coditect-ai/dms-go"
)

func main() {
    ctx := context.Background()

    // Initialize with config
    client := dms.NewClient(dms.Config{
        APIKey:     os.Getenv("CODITECT_API_KEY"),
        BaseURL:    "https://dms-api.coditect.ai/api/v1",
        Timeout:    30 * time.Second,
        MaxRetries: 3,
    })

    // Upload document
    file, _ := os.Open("./document.md")
    defer file.Close()

    doc, err := client.Documents.Upload(ctx, file, "document.md")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Uploaded: %s\n", doc.ID)

    // Wait for processing
    doc, err = client.Documents.WaitForProcessing(ctx, doc.ID, 120*time.Second)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Processed: %d chunks\n", doc.ChunkCount)

    // Search
    results, err := client.Search(ctx, &dms.SearchRequest{
        Query:          "authentication",
        Mode:           dms.SearchModeHybrid,
        TopK:           10,
        MinScore:       0.3,
        IncludeContent: true,
    })
    if err != nil {
        log.Fatal(err)
    }

    for _, r := range results.Results {
        fmt.Printf("%.2f: %s\n", r.Score, r.DocumentTitle)
    }

    // Analytics
    dashboard, err := client.Analytics.Dashboard(ctx)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Total docs: %d\n", dashboard.DocumentMetrics.TotalDocuments)
}

---

REST API (Direct)

For languages without an official SDK, use the REST API directly:

cURL Examples

# Search
curl -X POST https://dms-api.coditect.ai/api/v1/search \
  -H "X-API-Key: $CODITECT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "authentication", "mode": "hybrid", "top_k": 10}'

# Upload document
curl -X POST https://dms-api.coditect.ai/api/v1/documents/upload \
  -H "X-API-Key: $CODITECT_API_KEY" \
  -F "file=@document.md"

# List documents
curl https://dms-api.coditect.ai/api/v1/documents \
  -H "X-API-Key: $CODITECT_API_KEY"

# Get analytics
curl https://dms-api.coditect.ai/api/v1/analytics/dashboard \
  -H "X-API-Key: $CODITECT_API_KEY"

---

Best Practices

Connection Pooling

# Python - reuse client instance
client = DMSClient(api_key="...")
# Use across requests

# TypeScript - singleton pattern
let client: DMSClient | null = null;
export function getClient(): DMSClient {
  if (!client) {
    client = new DMSClient({ apiKey: process.env.API_KEY! });
  }
  return client;
}

Error Handling

Always handle rate limits with exponential backoff:

import time
from coditect import RateLimitError

def search_with_retry(query, max_retries=3):
    for attempt in range(max_retries):
        try:
            return client.search(query)
        except RateLimitError as e:
            if attempt == max_retries - 1:
                raise
            time.sleep(e.retry_after or (2 ** attempt))

Batch Operations

# Upload multiple documents efficiently
from concurrent.futures import ThreadPoolExecutor

files = ["doc1.md", "doc2.md", "doc3.md"]

with ThreadPoolExecutor(max_workers=5) as executor:
    docs = list(executor.map(client.documents.upload, files))

---

Support

• Python SDK Issues: https://github.com/coditect-ai/dms-python/issues
• TypeScript SDK Issues: https://github.com/coditect-ai/dms-typescript/issues
• Go SDK Issues: https://github.com/coditect-ai/dms-go/issues
• General Support: support@az1.ai