JavaScript/TypeScript SDK¶

import { SekhaClient } from '@sekha/sdk';

// Initialize with all services
const sekha = new SekhaClient({
  controllerURL: 'http://localhost:8080',
  bridgeURL: 'http://localhost:5001',
  apiKey: 'sk-your-api-key'
});

// One-line workflows
const response = await sekha.completeWithMemory(
  'Explain our TypeScript architecture',
  'TypeScript discussion'
);

console.log(response.choices[0].message.content);

import { MemoryController, MCPClient, BridgeClient } from '@sekha/sdk';

// REST API client
const controller = new MemoryController({
  baseURL: 'http://localhost:8080',
  apiKey: 'sk-your-api-key'
});

// MCP protocol client
const mcp = new MCPClient({
  baseURL: 'http://localhost:8080',
  mcpApiKey: 'sk-your-mcp-key'
});

// LLM Bridge client
const bridge = new BridgeClient({
  baseURL: 'http://localhost:5001'
});

// Use individually
const conversations = await controller.list();
const stats = await mcp.memoryStats({ folder: '/work' });
const completion = await bridge.complete({
  messages: [{ role: 'user', content: 'Hello!' }]
});

import { MemoryController } from '@sekha/sdk';

const controller = new MemoryController({
  baseURL: 'http://localhost:8080',
  apiKey: 'sk-your-api-key'
});

// Store conversation
const conversation = await controller.create({
  label: 'Engineering Discussion',
  folder: '/work/engineering',
  messages: [
    { role: 'user', content: 'How should we structure our API?' },
    { role: 'assistant', content: 'Let me suggest a REST-first approach...' }
  ]
});

// Semantic search
const results = await controller.query('API architecture discussion');
console.log(`Found ${results.total} results`);

// Full-text search
const ftsResults = await controller.searchFTS('TypeScript');

// Assemble context for LLM
const context = await controller.assembleContext({
  query: 'Continue the API discussion',
  context_budget: 4000,
  preferred_labels: ['Engineering']
});

import { MCPClient } from '@sekha/sdk';

const mcp = new MCPClient({
  baseURL: 'http://localhost:8080',
  mcpApiKey: 'sk-your-mcp-key'
});

// Store via MCP
const result = await mcp.memoryStore({
  label: 'Meeting Notes',
  folder: '/meetings',
  messages: [/* ... */]
});

// Search via MCP
const searchResult = await mcp.memorySearch({
  query: 'quarterly planning',
  limit: 10
});

// Get statistics
const stats = await mcp.memoryStats({
  folder: '/work',
  label: 'Engineering'
});

console.log(`Total: ${stats.total_conversations}`);
console.log(`Messages: ${stats.total_messages}`);

import { BridgeClient } from '@sekha/sdk';

const bridge = new BridgeClient({
  baseURL: 'http://localhost:5001'
});

// Chat completion
const completion = await bridge.complete({
  messages: [
    { role: 'system', content: 'You are a helpful assistant.' },
    { role: 'user', content: 'Explain TypeScript generics' }
  ],
  temperature: 0.7
});

console.log(completion.choices[0].message.content);

// Streaming completion
for await (const chunk of bridge.streamComplete({ messages })) {
  const content = chunk.choices[0]?.delta?.content;
  if (content) {
    process.stdout.write(content);
  }
}

// Generate embeddings
const embedding = await bridge.embed({
  text: 'This text will be embedded',
  model: 'text-embedding-3-small'
});

// Generate summary
const summary = await bridge.summarize({
  text: 'Long text to summarize...',
  level: 'brief'
});

import { SekhaClient } from '@sekha/sdk';

const sekha = new SekhaClient({
  controllerURL: 'http://localhost:8080',
  bridgeURL: 'http://localhost:5001',
  apiKey: 'sk-your-api-key'
});

// Access any client directly
await sekha.controller.list();
await sekha.mcp.memoryStats({});
await sekha.bridge.complete({ messages });

// High-level workflows:

// 1. Store conversation then search
const { conversation, results } = await sekha.storeAndQuery(
  messages,
  'search query',
  { label: 'Engineering', folder: '/work' }
);

// 2. LLM completion with assembled context
const response = await sekha.completeWithContext(
  'What were the main takeaways from our meeting?',
  'meeting notes',
  {
    context_budget: 4000,
    preferred_labels: ['Meetings'],
    temperature: 0.7
  }
);

// 3. LLM completion with search results
const response2 = await sekha.completeWithMemory(
  'Summarize our TypeScript discussions',
  'TypeScript architecture',
  { limit: 5 }
);

// 4. Generate custom embedding and store
const stored = await sekha.embedAndStore(
  messages,
  {
    label: 'Custom Embedded',
    folder: '/custom',
    model: 'text-embedding-3-large'
  }
);

// 5. Streaming with context
for await (const chunk of sekha.streamWithContext(
  'Continue our discussion',
  'previous conversation'
)) {
  process.stdout.write(chunk.choices[0]?.delta?.content || '');
}

// 6. Check all services
const health = await sekha.healthCheck();
console.log(`Controller: ${health.controller.status}`);
console.log(`Bridge: ${health.bridge.status}`);

import { Message } from '@sekha/sdk';

// Vision message with image
const visionMessage: Message = {
  role: 'user',
  content: [
    { type: 'text', text: 'What is in this image?' },
    { 
      type: 'image_url',
      image_url: {
        url: 'https://example.com/chart.png',
        detail: 'high'  // 'low' | 'high' | 'auto'
      }
    }
  ]
};

// Store vision conversation
await controller.create({
  label: 'Chart Analysis',
  folder: '/vision',
  messages: [visionMessage]
});

// Use with bridge
const analysis = await bridge.complete({
  messages: [visionMessage]
});

import {
  isMultiModalContent,
  extractText,
  extractImageUrls,
  hasImages,
  isValidStatus
} from '@sekha/sdk';

const message: Message = { /* ... */ };

// Check content type
if (isMultiModalContent(message.content)) {
  const text = extractText(message.content);
  const images = extractImageUrls(message.content);
  console.log(`Text: ${text}`);
  console.log(`Images: ${images.length}`);
}

// Check if message has images
if (hasImages(message)) {
  console.log('Message contains images');
}

// Validate conversation status
if (isValidStatus(conversation.status)) {
  // TypeScript knows: status is 'active' | 'archived' | 'pinned'
}

// Stream to console
for await (const chunk of bridge.streamComplete({
  messages: [{ role: 'user', content: 'Write a story' }],
  stream: true
})) {
  const delta = chunk.choices[0]?.delta;
  if (delta?.content) {
    process.stdout.write(delta.content);
  }
}

// Collect full response
let fullResponse = '';
for await (const chunk of bridge.streamComplete({ messages })) {
  const content = chunk.choices[0]?.delta?.content || '';
  fullResponse += content;
}
console.log('\nComplete response:', fullResponse);

import { SekhaError } from '@sekha/sdk';

try {
  const results = await controller.query('search');
} catch (error) {
  if (error instanceof SekhaError) {
    console.error(`API Error: ${error.message}`);
    console.error(`Status: ${error.statusCode}`);
    console.error(`Details:`, error.details);
  }
}

import type {
  MemoryController,
  MCPClient,
  BridgeClient,
  SekhaClient,
  Conversation,
  Message,
  MessageContent,
  ContentPart,
  SearchResult,
  QueryResponse,
  PruningSuggestion
} from '@sekha/sdk';

// All types are exported and fully documented
const query: QueryRequest = {
  query: 'test',
  limit: 10,
  filters: {
    folder: '/work',
    importanceMin: 7
  }
};

// BEFORE (v0.1.0)
const conversations = await controller.list();

// AFTER (v0.2.0)
const response = await controller.list();
const conversations = response.results;
console.log(`Total: ${response.total}`);

// BEFORE
interface Conversation {
  folder?: string;  // Optional
  messageCount?: number;  // camelCase
}

// AFTER
interface Conversation {
  folder: string;  // Required!
  message_count: number;  // snake_case
}

import { useState } from 'react';
import { SekhaClient } from '@sekha/sdk';

const sekha = new SekhaClient({
  controllerURL: 'http://localhost:8080',
  apiKey: process.env.REACT_APP_SEKHA_KEY!
});

function SearchComponent() {
  const [query, setQuery] = useState('');
  const [results, setResults] = useState([]);

  const handleSearch = async () => {
    const response = await sekha.controller.query(query);
    setResults(response.results);
  };

  return (
    <div>
      <input value={query} onChange={e => setQuery(e.target.value)} />
      <button onClick={handleSearch}>Search</button>

      <ul>
        {results.map(result => (
          <li key={result.conversation_id}>
            <strong>{result.label}</strong> ({result.score.toFixed(2)})
            <p>{result.content.substring(0, 200)}...</p>
          </li>
        ))}
      </ul>
    </div>
  );
}