Answer API

import { LLMLayerClient } from 'llmlayer';

// 1. Create a client with your API key
const client = new LLMLayerClient({
  apiKey: process.env.LLMLAYER_API_KEY
});

// 2. Ask a question
const response = await client.answer({
  query: 'What is the capital of France?',
  model: 'openai/gpt-4o-mini'  // Fast and affordable
});

// 3. Get your answer
console.log(response.answer);
// Output: "The capital of France is Paris..."

// 4. Check the cost
console.log(`Cost: $${response.llmlayer_cost}`);
// Output: "Cost: $0.004"

const response = await client.answer({
  query: 'Your question here',
  model: 'openai/gpt-4o-mini'
});

console.log('LLMLayer infrastructure:', response.llmlayer_cost);  // $0.004
console.log('Model usage:', response.model_cost);                 // ~$0.0002
console.log('Input tokens:', response.input_tokens);              // 500
console.log('Output tokens:', response.output_tokens);            // 200

const total = response.model_cost + response.llmlayer_cost;
console.log(`Total: $${total.toFixed(6)}`);                       // $0.004195

const response = await client.answer({
  query: 'What is the population of Tokyo?',
  model: 'openai/gpt-4o-mini',
  returnSources: true
});

console.log(response.answer);
console.log('\nSources:');
response.sources?.forEach(source => {
  console.log(`- ${source.title}`);
  console.log(`  ${source.link}`);
});
console.log(`\nTotal cost: $${response.model_cost + response.llmlayer_cost}`);

const response = await client.answer({
  query: 'Latest developments in renewable energy',
  model: 'openai/gpt-4.1-mini',     // Better for complex topics
  searchType: 'news',               // Search news articles
  dateFilter: 'week',               // Past week only
  citations: true,                  // Add citation markers
  returnSources: true,              // Get source list
  maxQueries: 2,                    // Broader coverage ($0.008 total)
  temperature: 0.5                  // Balanced
});

console.log(response.answer);
console.log('\nSources:', response.sources?.length);
console.log('LLMLayer cost:', response.llmlayer_cost);  // $0.008 (2 queries)

// Define what data structure you want
const schema = {
  type: 'object',
  properties: {
    summary: {
      type: 'string',
      description: 'Brief 2-sentence summary'
    },
    key_findings: {
      type: 'array',
      items: { type: 'string' },
      description: 'List of 3-5 key points'
    },
    companies_mentioned: {
      type: 'array',
      items: { type: 'string' }
    }
  },
  required: ['summary', 'key_findings']
};

const response = await client.answer({
  query: 'What are the major AI companies and their latest products?',
  model: 'openai/gpt-4o',
  answerType: 'json',           // JSON output
  jsonSchema: schema,           // Define structure
  maxQueries: 2,                // Better coverage
  searchContextSize: 'high'     // More information
});

// Parse the JSON response
const data = typeof response.answer === 'string'
  ? JSON.parse(response.answer)
  : response.answer;

console.log('Summary:', data.summary);
console.log('\nKey Findings:');
data.key_findings.forEach((finding, i) => {
  console.log(`${i + 1}. ${finding}`);
});
console.log('\nCompanies:', data.companies_mentioned.join(', '));

// Research medical information from trusted sources only
const response = await client.answer({
  query: 'What are the latest treatments for type 2 diabetes?',
  model: 'anthropic/claude-sonnet-4',  // Best for nuanced medical info
  domainFilter: [
    'pubmed.gov',           // Include: Medical database
    'nih.gov',              // Include: National health institute
    'mayoclinic.org',       // Include: Trusted medical source
    '-reddit.com',          // Exclude: User opinions
    '-pinterest.com'        // Exclude: Non-medical content
  ],
  searchContextSize: 'high',  // Maximum context
  temperature: 0.3,           // Factual
  returnSources: true
});

console.log(response.answer);
console.log('\nSources used:');
response.sources?.forEach(source => {
  const domain = new URL(source.link).hostname;
  console.log(`- ${source.title} (${domain})`);
});

const response = await client.answer({
  query: 'Explain the theory of relativity',
  model: 'openai/gpt-4o',
  providerKey: process.env.OPENAI_API_KEY,  // Use your OpenAI key
  maxTokens: 2000,
  temperature: 0.7
});

// When using your own key:
console.log('LLMLayer cost:', response.llmlayer_cost);  // $0.004 only
console.log('Model cost:', response.model_cost);        // null (you're billed by OpenAI)
console.log('Total from LLMLayer:', response.llmlayer_cost);

import { LLMLayerClient } from 'llmlayer';

const client = new LLMLayerClient({
  apiKey: process.env.LLMLAYER_API_KEY
});

// Start the stream
const stream = client.streamAnswer({
  query: 'Explain how photosynthesis works',
  model: 'openai/gpt-4o-mini',
  returnSources: true,
  temperature: 0.7
});

// Handle each event
for await (const event of stream) {
  switch (event.type) {
    case 'answer':
      // Print each chunk immediately (like ChatGPT!)
      process.stdout.write(event.content || '');
      break;

    case 'sources':
      console.log('\n\nSources:', event.data?.length);
      break;

    case 'usage':
      const total = (event.model_cost || 0) + (event.llmlayer_cost || 0);
      console.log(`\n\nCost: $${total.toFixed(4)}`);
      break;

    case 'done':
      console.log(`\nCompleted in ${event.response_time}s`);
      break;

    case 'error':
      console.error('Error:', event.error);
      break;
  }
}

import { useState } from 'react';
import { LLMLayerClient } from 'llmlayer';

function ChatInterface() {
  const [messages, setMessages] = useState([]);
  const [currentAnswer, setCurrentAnswer] = useState('');
  const [isStreaming, setIsStreaming] = useState(false);

  const client = new LLMLayerClient({
    apiKey: process.env.LLMLAYER_API_KEY
  });

  async function askQuestion(question: string) {
    setIsStreaming(true);
    setCurrentAnswer('');

    // Add user message
    setMessages(prev => [...prev, { role: 'user', content: question }]);

    try {
      const stream = client.streamAnswer({
        query: question,
        model: 'openai/gpt-4o-mini',
        temperature: 0.7
      });

      let fullAnswer = '';

      for await (const event of stream) {
        if (event.type === 'answer') {
          fullAnswer += event.content;
          setCurrentAnswer(fullAnswer);  // Update UI in real-time
        }

        if (event.type === 'done') {
          // Add complete answer to history
          setMessages(prev => [...prev, {
            role: 'assistant',
            content: fullAnswer
          }]);
          setCurrentAnswer('');
        }
      }
    } catch (error) {
      console.error('Stream error:', error);
    } finally {
      setIsStreaming(false);
    }
  }

  return (
    <div>
      {messages.map((msg, i) => (
        <div key={i} className={msg.role}>
          {msg.content}
        </div>
      ))}
      {currentAnswer && (
        <div className="assistant streaming">
          {currentAnswer}
          <span className="cursor">▋</span>
        </div>
      )}
    </div>
  );
}

import {
  LLMLayerClient,
  AuthenticationError,
  InvalidRequest,
  RateLimitError,
  ProviderError
} from 'llmlayer';

const client = new LLMLayerClient({
  apiKey: process.env.LLMLAYER_API_KEY
});

async function robustAnswer(query: string, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await client.answer({
        query,
        model: 'openai/gpt-4o-mini'
      });

    } catch (error) {
      // Authentication errors - don't retry
      if (error instanceof AuthenticationError) {
        console.error('❌ Fix your API key:', error.message);
        throw error;
      }

      // Validation errors - don't retry
      if (error instanceof InvalidRequest) {
        console.error('❌ Fix your request:', error.message);
        throw error;
      }

      // Rate limit - wait and retry
      if (error instanceof RateLimitError) {
        const waitTime = Math.pow(2, attempt) * 1000;  // Exponential backoff
        console.log(`⏳ Rate limited. Waiting ${waitTime}ms...`);
        await new Promise(resolve => setTimeout(resolve, waitTime));
        continue;  // Retry
      }

      // Provider error - try different model
      if (error instanceof ProviderError) {
        console.log('⚠️ Provider error, trying fallback model...');
        return await client.answer({
          query,
          model: 'groq/llama-3.3-70b-versatile'  // Fallback
        });
      }

      // Unknown error on last attempt
      if (attempt === maxRetries - 1) {
        console.error('❌ Max retries exceeded:', error);
        throw error;
      }

      // Wait before retry
      await new Promise(resolve => setTimeout(resolve, 1000));
    }
  }
}

// Usage
try {
  const response = await robustAnswer('What is machine learning?');
  console.log(response.answer);
} catch (error) {
  console.error('Failed after all retries:', error);
}