import { HashubVector } from 'hashub-vector';

// Initialize client
const client = new HashubVector({
  apiKey: 'your-api-key'
});

// Single text embedding
const response = await client.vectorize({
  text: 'Merhaba dünya! Hashub ile güçlü vektör embedding\'ler.',
  model: 'gte_base'
});

console.log(`Vector dimension: ${response.dimension}`);
console.log(`First 5 dimensions: ${response.vector.slice(0, 5)}`);

// Batch processing
const batchResponse = await client.vectorizeBatch({
  texts: [
    'Artificial intelligence is transforming the world',
    'Yapay zeka dünyayı dönüştürüyor',
    'L\'intelligence artificielle transforme le monde'
  ],
  model: 'gte_base'
});

console.log(`Processed ${batchResponse.count} texts`);
console.log(`Total tokens: ${batchResponse.totalTokens}`);

// Optimized for Turkish content
const response = await client.vectorize({
  text: 'Hashub Vector API ile Türkçe metinlerinizi güçlü vektörlere dönüştürün!',
  model: 'gte_base'  // Best for Turkish
});

// OpenAI style (compatible)
const response = await client.createEmbedding({
  input: 'Your text here',
  model: 'e5_base'
});

const embedding = response.data[0].embedding;
console.log(`Generated ${embedding.length}D embedding`);

// Multiple texts
const response = await client.createEmbedding({
  input: ['Text 1', 'Text 2', 'Text 3'],
  model: 'gte_base'
});

const client = new HashubVector({
  apiKey: 'your-api-key',
  baseUrl: 'https://api.vector.hashub.dev',  // Custom endpoint
  timeout: 30000,                             // 30 second timeout
  maxRetries: 3,                             // Retry failed requests
  headers: {                                 // Custom headers
    'X-Custom-Header': 'value'
  }
});

// Automatic chunking for long texts
const response = await client.vectorize({
  text: longDocument,
  model: 'gte_base',
  chunkSize: 1024,
  chunkOverlap: 0.1  // 10% overlap
});

console.log(`Document split into ${response.chunkCount} chunks`);

// Get available models
const models = await client.getModels();

for (const model of models) {
  console.log(`${model.alias}: ${model.description}`);
  console.log(`  Dimension: ${model.dimension}`);
  console.log(`  Max tokens: ${model.maxTokens}`);
  console.log(`  Turkish support: ${model.turkishSupport}/5`);
}

// Check your usage
const usage = await client.getUsage();
console.log(`Tokens used: ${usage.tokensUsed.toLocaleString()}`);
console.log(`Usage percentage: ${usage.tokensPercentageUsed.toFixed(1)}%`);

// Detailed usage with date range
const detailedUsage = await client.getDetailedUsage('2025-08-01', '2025-08-07');
console.log(`Daily breakdown: ${detailedUsage.dailyUsage.length} days`);

import { HashubVector } from 'hashub-vector';
import { useState, useEffect } from 'react';

function EmbeddingComponent() {
  const [client] = useState(() => new HashubVector({
    apiKey: process.env.NEXT_PUBLIC_HASHUB_API_KEY!
  }));
  
  const [embedding, setEmbedding] = useState<number[]>([]);

  const generateEmbedding = async (text: string) => {
    try {
      const response = await client.vectorize({
        text,
        model: 'e5_base'
      });
      setEmbedding(response.vector);
    } catch (error) {
      console.error('Embedding failed:', error);
    }
  };

  return (
    <div>
      <button onClick={() => generateEmbedding('Example text')}>
        Generate Embedding
      </button>
      {embedding.length > 0 && (
        <p>Generated {embedding.length}D embedding</p>
      )}
    </div>
  );
}

import express from 'express';
import { HashubVector } from 'hashub-vector';

const app = express();
const client = new HashubVector({
  apiKey: process.env.HASHUB_API_KEY!
});

app.use(express.json());

app.post('/embed', async (req, res) => {
  try {
    const { text, model = 'e5_base' } = req.body;
    
    const response = await client.vectorize({ text, model });
    
    res.json({
      success: true,
      embedding: response.vector,
      dimension: response.dimension,
      tokens: response.tokens
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
});

app.listen(3000, () => {
  console.log('Server running on port 3000');
});

import {
  HashubVector,
  AuthenticationError,
  RateLimitError,
  QuotaExceededError,
  ValidationError,
  ServerError,
  NetworkError,
  TimeoutError
} from 'hashub-vector';

const client = new HashubVector({ apiKey: 'your-key' });

try {
  const response = await client.vectorize({
    text: 'Your text',
    model: 'e5_base'
  });
} 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 QuotaExceededError) {
    console.log('Quota exceeded. Please upgrade your plan');
  } else if (error instanceof NetworkError) {
    console.log('Network connection issue');
  } else if (error instanceof TimeoutError) {
    console.log('Request timeout');
  }
}

import type {
  HashubVectorConfig,
  EmbeddingModel,
  VectorizeRequest,
  VectorizeResponse,
  // ... other types
} from 'hashub-vector';