Skip to main content

Quick Start Guide

Overview​

Welcome to the SVECTOR Quick Start Guide. This comprehensive tutorial will guide you through the essential steps to integrate SVECTOR's advanced artificial intelligence capabilities into your applications. SVECTOR provides state-of-the-art language models designed for enterprise-grade applications, offering superior performance in natural language processing, document analysis, and conversational AI systems.

What You'll Learn​

By following this guide, you will learn how to:

  • Set up and configure the SVECTOR SDK in your preferred programming environment
  • Implement basic text generation and conversational AI functionality
  • Utilize advanced features such as streaming responses and document processing
  • Integrate SVECTOR's powerful models into your existing applications
  • Follow best practices for production deployment and error handling

Prerequisites​

Before beginning, ensure you have:

  • A valid SVECTOR API key (obtain from SVECTOR Platform)
  • Basic knowledge of your chosen programming language
  • A development environment properly configured for your language of choice

Choose your preferred programming language below to begin your integration journey:

TypeScript SDK Integration​

The SVECTOR TypeScript SDK provides comprehensive type safety and modern JavaScript features for building robust AI-powered applications. This SDK is optimized for Node.js, Deno, and Bun environments, offering seamless integration with existing TypeScript projects.

Installation and Setup​

The SDK can be installed through multiple package managers depending on your runtime environment:

# For Node.js projects using npm
npm install svector-sdk

# For Deno projects using JSR (JavaScript Registry)
import { SVECTOR } from "jsr:@svector/svector";

# For Bun runtime environments
bun add svector-sdk

Fundamental Implementation​

This example demonstrates the core functionality of the SVECTOR SDK, showcasing how to initialize the client and perform basic text generation:

import { SVECTOR } from 'svector-sdk';

// Initialize the SVECTOR client with your API credentials
const client = new SVECTOR({
  apiKey: process.env.SVECTOR_API_KEY,
  // Optional: Configure additional client settings
  timeout: 30000,
  maxRetries: 3,
});

// Generate intelligent text responses using the Conversations API
const response = await client.conversations.create({
  model: 'spec-3-turbo',
  instructions: 'You are a knowledgeable AI assistant specializing in providing clear, accurate, and helpful responses.',
  input: 'Please provide a comprehensive explanation of machine learning fundamentals.',
  temperature: 0.7,
  max_tokens: 500,
});

console.log('AI Response:', response.output);
console.log('Usage Statistics:', response.usage);

Real-time Streaming Implementation​

For applications requiring real-time response generation, the streaming API provides server-sent events for immediate content delivery:

const stream = await client.conversations.createStream({
  model: 'spec-3-turbo',
  instructions: 'You are a creative storyteller with expertise in crafting engaging narratives.',
  input: 'Create an immersive science fiction story involving artificial intelligence and human cooperation.',
  stream: true,
  temperature: 0.8,
});

console.log('Story Generation:');
for await (const event of stream) {
  if (!event.done) {
    process.stdout.write(event.content);
  } else {
    console.log('\n✓ Story generation completed successfully');
  }
}

Advanced Document Processing​

The SDK supports sophisticated document analysis capabilities, enabling AI-powered insights from various file formats:

import fs from 'node:fs';

// Upload and process documents for AI analysis
const fileResponse = await client.files.create(
  fs.readFileSync('business-report.pdf'),
  'default',
  'business-report.pdf'
);

// Perform intelligent document analysis
const analysis = await client.conversations.create({
  model: 'spec-3-turbo',
  instructions: 'You are an expert business analyst. Provide detailed insights, key findings, and actionable recommendations based on the document content.',
  input: `Please conduct a comprehensive analysis of this business document, highlighting critical metrics, trends, and strategic implications:\n\n${fileResponse.data.content}`,
  temperature: 0.3, // Lower temperature for factual analysis
  max_tokens: 1000,
});

console.log('Document Analysis Results:', analysis.output);

Error Handling and Resilience​

Implement robust error handling to ensure application reliability:

import { AuthenticationError, RateLimitError, APIError } from 'svector-sdk';

try {
  const response = await client.conversations.create({
    model: 'spec-3-turbo',
    instructions: 'You are a helpful assistant.',
    input: 'Hello, world!',
  });
  
  console.log(response.output);
} catch (error) {
  if (error instanceof AuthenticationError) {
    console.error('Authentication failed. Please verify your API key.');
  } else if (error instanceof RateLimitError) {
    console.error('Rate limit exceeded. Please implement exponential backoff.');
  } else if (error instanceof APIError) {
    console.error(`API Error (${error.status}): ${error.message}`);
  } else {
    console.error('Unexpected error occurred:', error);
  }
}

SVECTOR AI Model Ecosystem​

SVECTOR has developed a comprehensive suite of state-of-the-art artificial intelligence models, each optimized for specific use cases and computational requirements. Our model family combines cutting-edge research in natural language processing, machine learning, and computational intelligence to deliver enterprise-grade AI solutions.

Model Specifications and Capabilities​

spec-3-turbo - High-Performance General Purpose Model​

  • Primary Use Case: Production applications requiring fast response times
  • Optimizations: Streamlined architecture for reduced latency while maintaining quality
  • Best For: Real-time chat applications, API integrations, customer service automation
  • Performance: Sub-second response times with excellent accuracy
  • Context Window: Up to 1M tokens for extensive document processing

spec-3 - Balanced Performance and Quality Model​

  • Primary Use Case: Applications requiring optimal balance between speed and sophistication
  • Optimizations: Enhanced reasoning capabilities with moderate computational overhead
  • Best For: Content creation, analysis tasks, educational applications
  • Performance: Superior quality outputs with reasonable processing times
  • Context Window: Up to 1M tokens with advanced context retention

theta-35 - Advanced Reasoning and Analysis Model​

  • Primary Use Case: Complex problem-solving and deep analytical tasks
  • Optimizations: Maximum reasoning capabilities and nuanced understanding
  • Best For: Research analysis, strategic planning, complex document interpretation
  • Performance: Highest quality outputs for demanding intellectual tasks
  • Context Window: Up to 40k tokens for extensive context handling for reasoning tasks

theta-35-mini - Efficient Lightweight Model​

  • Primary Use Case: Lightweight applications with reasoning capabilities
  • Optimizations: Minimal computational requirements while maintaining core functionality
  • Best For: Basic Q&A, simple content generation, embedded applications
  • Performance: Fast execution with lower resource consumption
  • Context Window: Up to 40k tokens for extensive context handling, optimized for faster reasoning tasks

spec-2-mini - Super Fast Responses Model​

  • Primary Use Case: Applications requiring extremely fast responses with basic quality
  • Optimizations: High-speed processing with minimal computational overhead
  • Best For: Simple chatbots, quick information retrieval, low-latency applications
  • Performance: Sub-second response times with basic quality outputs
  • Context Window: Up to 32k tokens for rapid context handling

Model Selection Guidelines​

When choosing the appropriate model for your application, consider the following factors:

# Performance-critical applications
model = "spec-3-turbo"  # Optimized for speed

# Balanced applications requiring quality and performance
model = "spec-3"  # Best overall choice for most use cases

# Complex analytical tasks requiring deep reasoning
model = "theta-35"  # Advanced reasoning capabilities

# Resource-constrained or simple applications  
model = "theta-35-mini"  # Efficient processing for faster reasoning tasks

Advanced Integration Strategies​

Enterprise Deployment Considerations​

For enterprise-grade deployments, implement the following best practices:

Configuration Management​

import os
from typing import Optional

class SVECTORConfig:
    """Centralized configuration management for SVECTOR integrations."""
    
    def __init__(self):
        self.api_key: str = os.environ.get("SVECTOR_API_KEY", "")
        self.base_url: str = os.environ.get("SVECTOR_BASE_URL", "https://api.svector.co.in")
        self.timeout: int = int(os.environ.get("SVECTOR_TIMEOUT", "60"))
        self.max_retries: int = int(os.environ.get("SVECTOR_MAX_RETRIES", "3"))
        self.default_model: str = os.environ.get("SVECTOR_DEFAULT_MODEL", "spec-3-turbo")
        
    def validate(self) -> bool:
        """Validate configuration parameters."""
        if not self.api_key:
            raise ValueError("SVECTOR_API_KEY environment variable is required")
        return True

Production Monitoring and Observability​

import logging
import time
from functools import wraps

def monitor_ai_requests(func):
    """Decorator for monitoring AI API requests in production."""
    @wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.time()
        logger = logging.getLogger(__name__)
        
        try:
            result = func(*args, **kwargs)
            duration = time.time() - start_time
            
            logger.info(f"AI Request completed successfully", extra={
                "function": func.__name__,
                "duration_seconds": duration,
                "model": kwargs.get("model", "unknown"),
                "success": True
            })
            
            return result
            
        except Exception as error:
            duration = time.time() - start_time
            
            logger.error(f"AI Request failed", extra={
                "function": func.__name__,
                "duration_seconds": duration,
                "error": str(error),
                "error_type": type(error).__name__,
                "success": False
            })
            
            raise
    
    return wrapper

Production-Ready Implementation Examples​

Scalable Document Processing Pipeline​

from concurrent.futures import ThreadPoolExecutor, as_completed
from typing import List, Dict, Any
import threading

class DocumentProcessingPipeline:
    """Enterprise-grade document processing system using SVECTOR AI."""
    
    def __init__(self, max_workers: int = 5):
        self.client = SVECTOR()
        self.max_workers = max_workers
        self.processing_stats = {
            "total_processed": 0,
            "successful": 0,
            "failed": 0,
            "processing_times": []
        }
        self.stats_lock = threading.Lock()
    
    def process_single_document(self, file_path: str, analysis_type: str) -> Dict[str, Any]:
        """Process a single document with comprehensive error handling."""
        start_time = time.time()
        
        try:
            # Upload document
            with open(file_path, "rb") as file:
                file_response = self.client.files.create(
                    file=file,
                    purpose="default",
                    filename=os.path.basename(file_path)
                )
            
            # Generate analysis based on type
            analysis_instructions = {
                "summary": "You are an expert document summarizer. Provide comprehensive yet concise summaries highlighting key points, conclusions, and actionable insights.",
                "compliance": "You are a compliance expert. Analyze documents for regulatory compliance, identify potential risks, and recommend corrective actions.",
                "financial": "You are a senior financial analyst. Examine financial documents for trends, anomalies, performance indicators, and strategic implications.",
                "legal": "You are a legal expert specializing in contract and document review. Identify key terms, obligations, risks, and recommendations."
            }
            
            response = self.client.conversations.create(
                model="theta-35",  # Use advanced model for document analysis
                instructions=analysis_instructions.get(analysis_type, analysis_instructions["summary"]),
                input=f"Please conduct a thorough {analysis_type} analysis of this document. Provide detailed insights, findings, and recommendations.",
                files=[{"type": "file", "id": file_response.file_id}],
                temperature=0.2,  # Lower temperature for factual analysis
                max_tokens=2000
            )
            
            processing_time = time.time() - start_time
            
            # Update statistics
            with self.stats_lock:
                self.processing_stats["total_processed"] += 1
                self.processing_stats["successful"] += 1
                self.processing_stats["processing_times"].append(processing_time)
            
            return {
                "file_path": file_path,
                "analysis_type": analysis_type,
                "success": True,
                "analysis": response.output,
                "processing_time": processing_time,
                "token_usage": response.usage,
                "file_id": file_response.file_id
            }
            
        except Exception as error:
            processing_time = time.time() - start_time
            
            with self.stats_lock:
                self.processing_stats["total_processed"] += 1
                self.processing_stats["failed"] += 1
                self.processing_stats["processing_times"].append(processing_time)
            
            return {
                "file_path": file_path,
                "analysis_type": analysis_type,
                "success": False,
                "error": str(error),
                "error_type": type(error).__name__,
                "processing_time": processing_time
            }
    
    def process_documents_batch(self, documents: List[Dict[str, str]]) -> List[Dict[str, Any]]:
        """Process multiple documents concurrently for optimal performance."""
        
        print(f"Processing {len(documents)} documents using {self.max_workers} workers...")
        
        results = []
        with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
            # Submit all tasks
            future_to_doc = {
                executor.submit(
                    self.process_single_document, 
                    doc["file_path"], 
                    doc["analysis_type"]
                ): doc for doc in documents
            }
            
            # Collect results as they complete
            for future in as_completed(future_to_doc):
                result = future.result()
                results.append(result)
                
                # Progress reporting
                if result["success"]:
                    print(f"✓ Successfully processed: {result['file_path']}")
                else:
                    print(f"✗ Failed to process: {result['file_path']} - {result['error']}")
        
        self.print_processing_summary()
        return results
    
    def print_processing_summary(self):
        """Print comprehensive processing statistics."""
        with self.stats_lock:
            stats = self.processing_stats.copy()
        
        if stats["processing_times"]:
            avg_time = sum(stats["processing_times"]) / len(stats["processing_times"])
            total_time = sum(stats["processing_times"])
        else:
            avg_time = total_time = 0
        
        print("\n" + "="*60)
        print("DOCUMENT PROCESSING SUMMARY")
        print("="*60)
        print(f"Total Documents Processed: {stats['total_processed']}")
        print(f"Successful: {stats['successful']}")
        print(f"Failed: {stats['failed']}")
        print(f"Success Rate: {(stats['successful']/stats['total_processed']*100):.1f}%" if stats['total_processed'] > 0 else "N/A")
        print(f"Average Processing Time: {avg_time:.2f} seconds")
        print(f"Total Processing Time: {total_time:.2f} seconds")
        print("="*60)

# Example usage for enterprise document processing
if __name__ == "__main__":
    # Define document processing jobs
    documents_to_process = [
        {"file_path": "./contracts/vendor_agreement_2024.pdf", "analysis_type": "legal"},
        {"file_path": "./financial/q4_financial_report.pdf", "analysis_type": "financial"},
        {"file_path": "./compliance/audit_report.pdf", "analysis_type": "compliance"},
        {"file_path": "./research/market_analysis.docx", "analysis_type": "summary"},
        {"file_path": "./policies/security_policy.pdf", "analysis_type": "compliance"}
    ]
    
    # Initialize and run processing pipeline
    pipeline = DocumentProcessingPipeline(max_workers=3)
    results = pipeline.process_documents_batch(documents_to_process)
    
    # Generate comprehensive report
    successful_results = [r for r in results if r["success"]]
    
    print(f"\nGenerating consolidated analysis report...")
    
    if successful_results:
        # Create consolidated report using all successful analyses
        consolidated_input = "\n\n".join([
            f"=== {result['analysis_type'].upper()} ANALYSIS: {os.path.basename(result['file_path'])} ===\n{result['analysis']}"
            for result in successful_results
        ])
        
        consolidated_response = pipeline.client.conversations.create(
            model="theta-35",
            instructions="""You are a senior executive analyst. Create a comprehensive executive summary that synthesizes insights from multiple document analyses. 
            
            Structure your response as:
            1. Executive Summary
            2. Key Findings by Category
            3. Cross-Document Insights and Patterns
            4. Risk Assessment
            5. Strategic Recommendations
            6. Action Items and Next Steps""",
            input=f"Please create a comprehensive executive summary based on the following document analyses:\n\n{consolidated_input}",
            temperature=0.3,
            max_tokens=3000
        )
        
        print("\n" + "="*80)
        print("EXECUTIVE SUMMARY REPORT")
        print("="*80)
        print(consolidated_response.output)
        print("="*80)

Getting Started Checklist​

Before integrating SVECTOR into your production environment, ensure you have completed the following steps:

1. Account Setup and Authentication​

  • Create a SVECTOR account at platform.svector.co.in
  • Generate and securely store your API key
  • Configure environment variables for API credentials
  • Test API connectivity with a simple request

2. Development Environment Configuration​

  • Install the appropriate SDK for your programming language
  • Set up proper error handling and logging
  • Configure timeout and retry parameters
  • Implement monitoring and observability measures

3. Model Selection and Testing​

  • Evaluate different models with your specific use cases
  • Benchmark performance and quality metrics
  • Test with representative data samples
  • Optimize parameters (temperature, max_tokens, etc.)

4. Security and Compliance​

  • Implement secure API key management
  • Review data privacy and retention policies
  • Ensure compliance with relevant regulations
  • Set up audit logging for API usage

5. Production Deployment​

  • Configure load balancing and scaling
  • Set up monitoring and alerting
  • Implement graceful error handling
  • Plan for disaster recovery and failover

Next Steps and Advanced Features​

Advanced Capabilities to Explore​

  • Multi-Modal Processing: Integrate image analysis with text generation for comprehensive AI solutions
  • Custom Function Calling: Extend model capabilities with your own APIs and data sources
  • Real-time Streaming: Build interactive applications with server-sent events
  • Knowledge Base Integration: Create sophisticated RAG (Retrieval-Augmented Generation) systems
  • Agent-Based Architectures: Develop autonomous AI agents for complex workflow automation

Specialized Applications​

  • Document Intelligence: Advanced document processing, extraction, and analysis
  • Conversational AI: Build sophisticated chatbots and virtual assistants
  • Content Generation: Automated content creation for marketing, documentation, and creative writing
  • Data Analysis: AI-powered insights from structured and unstructured data
  • Code Generation: Automated programming assistance and code review

Authentication and Security​

API Key Management​

Obtain your API key from the SVECTOR Platform and implement secure storage practices:

# Set environment variable (recommended approach)
export SVECTOR_API_KEY="your-api-key-here"

# For production environments, use secure key management systems
# Examples: AWS Secrets Manager, Azure Key Vault, HashiCorp Vault

Security Best Practices​

  • Never hardcode API keys in source code or version control systems
  • Use environment variables or secure configuration management
  • Implement proper access controls and principle of least privilege
  • Monitor API usage for unusual patterns or unauthorized access
  • Rotate API keys regularly as part of security hygiene
  • Use HTTPS/TLS for all API communications

Support and Resources​

Technical Support​

Additional Resources​

  • API Reference: Comprehensive API documentation with examples
  • Best Practices Guide: Advanced patterns and optimization techniques
  • Use Case Studies: Real-world implementation examples and case studies
  • Performance Optimization: Guidelines for scaling and optimizing SVECTOR integrations

Enterprise Support​

For enterprise customers requiring dedicated support, custom integrations, or on-premises deployments, contact our enterprise team at enterprise@svector.co.in to discuss:

  • Custom model training and fine-tuning
  • Dedicated infrastructure and private cloud deployments
  • 24/7 technical support with guaranteed response times
  • Professional services for integration and optimization
  • Compliance consulting for regulated industries