// chat-app.js
// A command-line chat application using the Ollama SDK

const { OllamaKit } = require('@tekimax/ollama-sdk');
const readline = require('node:readline');
const chalk = require('chalk');

// Initialize the client
const ollama = new OllamaKit();

// Configuration
const config = {
  defaultModel: 'llama2',
  defaultSystemPrompt: 'You are a helpful, friendly assistant. You give concise and accurate responses.',
  temperature: 0.7,
  maxHistoryLength: 10, // Limit history to prevent context overflow
};

// Chat state
const state = {
  history: [],
  model: config.defaultModel,
  systemPrompt: config.defaultSystemPrompt,
  temperature: config.temperature,
};

// Terminal UI
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

// Format messages for display
function formatMessage(role, content) {
  if (role === 'user') {
    return chalk.bold.blue(`You: ${content}`);
  } else if (role === 'assistant') {
    return chalk.bold.green(`Assistant: ${content}`);
  } else if (role === 'system') {
    return chalk.yellow(`[System: ${content}]`);
  }
  return content;
}

// Convert history to a format suitable for the model
function formatHistoryForModel() {
  // Most Ollama models just need the conversation as a single text
  let conversationText = '';
  
  // Add the system prompt at the beginning
  conversationText += `${state.systemPrompt}\n\n`;
  
  // Add conversation history
  for (const message of state.history) {
    if (message.role === 'user') {
      conversationText += `User: ${message.content}\n`;
    } else if (message.role === 'assistant') {
      conversationText += `Assistant: ${message.content}\n`;
    }
  }
  
  return conversationText;
}

// Get response from the model
async function getResponse(userMessage) {
  try {
    // Add user message to history
    state.history.push({ role: 'user', content: userMessage });
    
    // Trim history if too long
    if (state.history.length > config.maxHistoryLength * 2) { // *2 because each exchange has 2 messages
      // Keep system prompt and remove oldest exchanges
      state.history = state.history.slice(-config.maxHistoryLength * 2);
    }
    
    // Format the complete conversation history
    const conversationContext = formatHistoryForModel();
    
    // Get streaming response
    console.log(chalk.dim('Assistant is typing...'));
    
    const stream = await ollama.generateStream({
      model: state.model,
      prompt: userMessage,
      system: state.systemPrompt,
      temperature: state.temperature,
      context: state.history.length > 1 ? undefined : null, // Only use context after first exchange
    });
    
    process.stdout.write(chalk.bold.green('Assistant: '));
    
    let fullResponse = '';
    for await (const chunk of stream) {
      process.stdout.write(chalk.green(chunk.response));
      fullResponse += chunk.response;
    }
    
    console.log('\n');
    
    // Add assistant response to history
    state.history.push({ role: 'assistant', content: fullResponse });
    
    return fullResponse;
  } catch (error) {
    console.error(chalk.red(`Error: ${error.message}`));
    return null;
  }
}

// Handle commands
function handleCommand(input) {
  const cmd = input.slice(1).split(' ')[0].toLowerCase();
  const args = input.slice(cmd.length + 2).trim();
  
  switch (cmd) {
    case 'help':
      console.log(chalk.cyan('\nAvailable commands:'));
      console.log(chalk.cyan('/help') + ' - Show this help message');
      console.log(chalk.cyan('/model [name]') + ' - Change the model or show current model');
      console.log(chalk.cyan('/system [prompt]') + ' - Change the system prompt or show current system prompt');
      console.log(chalk.cyan('/temp [0.0-1.0]') + ' - Change temperature or show current temperature');
      console.log(chalk.cyan('/clear') + ' - Clear conversation history');
      console.log(chalk.cyan('/exit') + ' - Exit the chat');
      break;
      
    case 'model':
      if (args) {
        state.model = args;
        console.log(chalk.yellow(`Model changed to: ${state.model}`));
      } else {
        console.log(chalk.yellow(`Current model: ${state.model}`));
      }
      break;
      
    case 'system':
      if (args) {
        state.systemPrompt = args;
        console.log(chalk.yellow(`System prompt changed to: "${state.systemPrompt}"`));
      } else {
        console.log(chalk.yellow(`Current system prompt: "${state.systemPrompt}"`));
      }
      break;
      
    case 'temp':
      if (args) {
        const temp = parseFloat(args);
        if (!isNaN(temp) && temp >= 0 && temp <= 1) {
          state.temperature = temp;
          console.log(chalk.yellow(`Temperature changed to: ${state.temperature}`));
        } else {
          console.log(chalk.red('Invalid temperature. Please use a value between 0.0 and 1.0'));
        }
      } else {
        console.log(chalk.yellow(`Current temperature: ${state.temperature}`));
      }
      break;
      
    case 'clear':
      state.history = [];
      console.log(chalk.yellow('Conversation history cleared.'));
      break;
      
    case 'exit':
      console.log(chalk.yellow('Goodbye!'));
      rl.close();
      process.exit(0);
      break;
      
    default:
      console.log(chalk.red(`Unknown command: ${cmd}. Type /help for available commands.`));
  }
}

// Main chat loop
async function startChat() {
  // Display welcome message
  console.log(chalk.bold('🤖 Ollama Chat'));
  console.log(chalk.dim('Type your messages to chat with the AI assistant.'));
  console.log(chalk.dim('Type /help for available commands.'));
  console.log(chalk.dim(`Current model: ${state.model}`));
  console.log(chalk.yellow(`[System: ${state.systemPrompt}]`));
  console.log('');
  
  // Check available models
  try {
    const modelsList = await ollama.listModels();
    const modelNames = modelsList.models.map(m => m.name);
    
    if (!modelNames.includes(state.model)) {
      console.log(chalk.yellow(`Warning: Model '${state.model}' may not be available.`));
      console.log(chalk.yellow(`Available models: ${modelNames.join(', ')}`));
    }
  } catch (error) {
    console.error(chalk.red(`Error checking models: ${error.message}`));
  }
  
  // Start chat loop
  function askQuestion() {
    rl.question(chalk.bold.blue('You: '), async (input) => {
      // Handle empty input
      if (!input.trim()) {
        askQuestion();
        return;
      }
      
      // Handle commands
      if (input.startsWith('/')) {
        handleCommand(input);
        askQuestion();
        return;
      }
      
      // Get response from the model
      await getResponse(input);
      
      // Continue the conversation
      askQuestion();
    });
  }
  
  askQuestion();
}

// Start the chat application
startChat(); 

// semantic-search.js
// Basic semantic search implementation using Ollama SDK

const { OllamaKit } = require('@tekimax/ollama-sdk');
const fs = require('fs').promises;
const path = require('path');

// Initialize the client
const ollama = new OllamaKit();

// Configuration
const config = {
  embeddingModel: 'nomic-embed-text',
  documentsDir: './documents',
  outputFile: './document-embeddings.json',
  topResults: 3,
};

// Vector utilities
const vectorUtils = {
  // Calculate cosine similarity between two vectors
  cosineSimilarity: (vec1, vec2) => {
    if (!vec1 || !vec2 || vec1.length !== vec2.length) {
      throw new Error('Vectors must be of the same length');
    }
    
    // Calculate dot product
    let dotProduct = 0;
    for (let i = 0; i < vec1.length; i++) {
      dotProduct += vec1[i] * vec2[i];
    }
    
    // Calculate magnitudes
    const mag1 = Math.sqrt(vec1.reduce((sum, val) => sum + val * val, 0));
    const mag2 = Math.sqrt(vec2.reduce((sum, val) => sum + val * val, 0));
    
    if (mag1 === 0 || mag2 === 0) return 0;
    
    // Cosine similarity
    return dotProduct / (mag1 * mag2);
  },
  
  // Find the most similar documents
  findMostSimilar: (queryEmbedding, documents, topK = 3) => {
    // Calculate similarity scores
    const withScores = documents.map(doc => ({
      ...doc,
      score: vectorUtils.cosineSimilarity(queryEmbedding, doc.embedding),
    }));
    
    // Sort by similarity score (descending)
    const sorted = withScores.sort((a, b) => b.score - a.score);
    
    // Return the top K results
    return sorted.slice(0, topK);
  },
};

// Main functions
async function createDocumentEmbeddings() {
  try {
    console.log(`📚 Creating embeddings for documents in ${config.documentsDir}...`);
    
    // Get all text files in the documents directory
    const files = await fs.readdir(config.documentsDir);
    const textFiles = files.filter(file => file.endsWith('.txt'));
    
    if (textFiles.length === 0) {
      console.log('No text files found in the documents directory.');
      return [];
    }
    
    console.log(`Found ${textFiles.length} text files.`);
    
    // Process each file
    const documents = [];
    
    for (const file of textFiles) {
      const filePath = path.join(config.documentsDir, file);
      const content = await fs.readFile(filePath, 'utf-8');
      
      // Split the content into paragraphs
      const paragraphs = content.split(/\n\s*\n/);
      
      console.log(`Processing ${file}: ${paragraphs.length} paragraphs`);
      
      // Create embeddings for each paragraph
      for (let i = 0; i < paragraphs.length; i++) {
        const paragraph = paragraphs[i].trim();
        if (paragraph.length < 10) continue; // Skip very short paragraphs
        
        console.log(`  Creating embedding for paragraph ${i+1}/${paragraphs.length}`);
        
        const embedding = await ollama.createEmbedding({
          model: config.embeddingModel,
          prompt: paragraph,
        });
        
        documents.push({
          id: `${file}-${i}`,
          file,
          paragraph: i,
          text: paragraph,
          embedding: embedding.embedding,
        });
      }
    }
    
    // Save embeddings to file
    await fs.writeFile(
      config.outputFile, 
      JSON.stringify({ documents, timestamp: new Date().toISOString() }, null, 2)
    );
    
    console.log(`✅ Created ${documents.length} document embeddings.`);
    console.log(`💾 Saved to ${config.outputFile}`);
    
    return documents;
  } catch (error) {
    console.error('Error creating document embeddings:', error);
    throw error;
  }
}

async function searchDocuments(query, documents) {
  try {
    console.log(`🔍 Searching for: "${query}"`);
    
    // Create embedding for the query
    const queryEmbedding = await ollama.createEmbedding({
      model: config.embeddingModel,
      prompt: query,
    });
    
    // Find the most similar documents
    const results = vectorUtils.findMostSimilar(
      queryEmbedding.embedding,
      documents,
      config.topResults
    );
    
    // Display results
    console.log(`\n📊 Top ${results.length} results:`);
    results.forEach((result, index) => {
      console.log(`\n#${index+1} (Score: ${result.score.toFixed(4)}) - ${result.file}:`);
      console.log(`${'─'.repeat(50)}`);
      console.log(result.text);
      console.log(`${'─'.repeat(50)}`);
    });
    
    return results;
  } catch (error) {
    console.error('Error searching documents:', error);
    throw error;
  }
}

// Main execution
async function main() {
  try {
    let documents;
    
    // Check if embeddings file exists
    try {
      const data = await fs.readFile(config.outputFile, 'utf-8');
      const parsed = JSON.parse(data);
      documents = parsed.documents;
      console.log(`📂 Loaded ${documents.length} existing document embeddings.`);
      console.log(`   Created: ${parsed.timestamp}`);
    } catch (e) {
      // If file doesn't exist or is invalid, create new embeddings
      console.log('No existing embeddings found. Creating new embeddings...');
      documents = await createDocumentEmbeddings();
    }
    
    if (!documents || documents.length === 0) {
      console.log('No documents available for search. Please add text files to the documents directory.');
      return;
    }
    
    // Interactive search loop
    const readline = require('readline').createInterface({
      input: process.stdin,
      output: process.stdout,
    });
    
    const askQuestion = () => {
      readline.question('\n✨ Enter your search query (or type "exit" to quit): ', async (query) => {
        if (query.toLowerCase() === 'exit') {
          console.log('👋 Goodbye!');
          readline.close();
          return;
        }
        
        if (query.trim().length === 0) {
          console.log('Please enter a valid query.');
          askQuestion();
          return;
        }
        
        await searchDocuments(query, documents);
        askQuestion();
      });
    };
    
    console.log('\n🔎 Semantic Search Demo');
    console.log('Enter your questions to search across the document collection.');
    askQuestion();
    
  } catch (error) {
    console.error('An error occurred:', error);
    process.exit(1);
  }
}

main(); 

// tools-example.js
// Example of using Ollama with tools for function calling

const { OllamaKit } = require('@tekimax/ollama-sdk');
const fs = require('fs').promises;
const path = require('path');

// Initialize Ollama client
const ollama = new OllamaKit();

// Define tools (can also be loaded from a JSON file)
const tools = [
  {
    type: "function",
    name: "fetch_weather",
    description: "Get the current weather for a location",
    parameters: {
      type: "object",
      required: ["location"],
      properties: {
        location: {
          type: "string",
          description: "The city name, e.g., 'New York' or 'London'"
        },
        unit: {
          type: "string",
          enum: ["celsius", "fahrenheit"],
          description: "The temperature unit",
          default: "celsius"
        }
      }
    }
  },
  {
    type: "function",
    name: "search_products",
    description: "Search for products in an online store",
    parameters: {
      type: "object",
      required: ["query"],
      properties: {
        query: {
          type: "string",
          description: "The search query, e.g., 'blue t-shirt'"
        },
        category: {
          type: "string",
          description: "Product category filter",
          enum: ["electronics", "clothing", "books", "home"]
        },
        max_price: {
          type: "number",
          description: "Maximum price filter"
        },
        sort_by: {
          type: "string",
          enum: ["relevance", "price_low_to_high", "price_high_to_low", "newest"],
          default: "relevance"
        }
      }
    }
  }
];

// Mock tool execution functions
async function fetchWeather(params) {
  console.log(`🌤️ Fetching weather for ${params.location}...`);
  // In a real app, this would call a weather API
  return {
    location: params.location,
    temperature: 22,
    unit: params.unit || "celsius",
    condition: "Sunny",
    humidity: 45,
    wind_speed: 10,
    last_updated: new Date().toISOString()
  };
}

async function searchProducts(params) {
  console.log(`🔍 Searching products for: ${params.query}`);
  // In a real app, this would search a product database
  return {
    results: [
      {
        id: "prod-1",
        name: `${params.query} - Product 1`,
        price: 29.99,
        category: params.category || "electronics",
        rating: 4.5,
        in_stock: true
      },
      {
        id: "prod-2",
        name: `${params.query} - Product 2`,
        price: 39.99,
        category: params.category || "electronics",
        rating: 4.2,
        in_stock: true
      }
    ],
    total_results: 2,
    filters_applied: {
      category: params.category,
      max_price: params.max_price,
      sort_by: params.sort_by || "relevance"
    }
  };
}

// Map tool names to their execution functions
const toolExecutors = {
  fetch_weather: fetchWeather,
  search_products: searchProducts
};

// Function to execute a tool
async function executeTool(toolCall) {
  const { name, input } = toolCall;
  
  if (!toolExecutors[name]) {
    return { error: `Tool '${name}' not found` };
  }
  
  try {
    return await toolExecutors[name](input);
  } catch (error) {
    return { error: error.message };
  }
}

// Main function that demonstrates the tools workflow
async function demonstrateTools() {
  console.log("🛠️ Demonstrating Ollama Tools Functionality");
  console.log("===========================================");
  
  // The user prompt that may require tool use
  const prompt = "I need to know the current weather in Paris and also find some good headphones to buy.";
  const model = "llama3"; // or any model that supports tool calling
  
  console.log(`\n📝 User prompt: "${prompt}"`);
  console.log(`🤖 Model: ${model}`);
  console.log(`🧰 Available tools: ${tools.map(t => t.name).join(", ")}\n`);
  
  try {
    console.log("Step 1: Sending initial request to the model...");
    const initialResponse = await ollama.tools.callWithTools({
      model,
      prompt,
      tools,
      temperature: 0.7
    });
    
    console.log(`\n🤖 Model response: "${initialResponse.message.content.trim()}"`);
    
    // Check if any tools were called
    if (initialResponse.message.tool_calls && initialResponse.message.tool_calls.length > 0) {
      console.log(`\n⚡ The model wants to use ${initialResponse.message.tool_calls.length} tools:`);
      
      // Process each tool call
      const toolCalls = initialResponse.message.tool_calls;
      const toolResponses = [];
      
      for (const toolCall of toolCalls) {
        console.log(`\n🔧 Tool: ${toolCall.name}`);
        console.log(`📥 Input: ${JSON.stringify(toolCall.input, null, 2)}`);
        
        // Execute the tool
        console.log(`⚙️ Executing tool...`);
        const toolResult = await executeTool(toolCall);
        console.log(`📤 Result: ${JSON.stringify(toolResult, null, 2)}`);
        
        // Save the tool response
        toolResponses.push({
          tool_call_id: toolCall.id,
          role: "tool",
          name: toolCall.name,
          content: JSON.stringify(toolResult)
        });
      }
      
      // Step 3: Send the tool responses back to the model
      console.log("\nStep 3: Sending tool responses back to the model...");
      const followUpResponse = await ollama.tools.executeToolCalls(
        {
          model,
          prompt,
          tools
        },
        toolCalls,
        toolResponses
      );
      
      console.log(`\n🤖 Final model response with tool results:\n\n"${followUpResponse.message.content.trim()}"`);
    } else {
      console.log("\n📢 No tools were called by the model.");
    }
  } catch (error) {
    console.error(`❌ Error: ${error.message}`);
    
    if (error.message.includes('not supported') || error.message.includes('not found')) {
      console.log("\n⚠️  Note: Tool calling might not be supported by this model or Ollama version.");
      console.log("Make sure you're using a model that supports function/tool calling like Llama 3.");
    }
  }
}

// Execute the demonstration
demonstrateTools().catch(console.error); 

// Example of using the OpenAI compatibility layer with Express.js
const express = require('express');
const cors = require('cors');
const { OllamaClient } = require('@tekimax/ollama-sdk');

// Create an Express app
const app = express();
app.use(express.json());
app.use(cors());

// Initialize the Ollama client
const client = new OllamaClient({
  baseUrl: process.env.OLLAMA_API_URL || 'http://localhost:11434'
});

// Configure and set up the OpenAI compatibility endpoints
(async () => {
  try {
    await client.openai.setupEndpoints(app);
    console.log('OpenAI compatibility layer endpoints set up successfully.');
  } catch (error) {
    console.error('Failed to set up OpenAI compatibility layer:', error);
  }
})();

// Start the server
const port = process.env.PORT || 3000;
app.listen(port, () => {
  console.log(`OpenAI compatibility server running on http://localhost:${port}`);
  console.log(`You can use this with any OpenAI client by pointing to this URL.`);
  console.log('Example with OpenAI Node.js SDK:');
  console.log(`
  import OpenAI from 'openai'
  
  const openai = new OpenAI({
    baseURL: 'http://localhost:${port}/v1/',
    apiKey: 'ollama',  // Any value works, it's just a placeholder
  })
  
  const chatCompletion = await openai.chat.completions.create({
    messages: [{ role: 'user', content: 'Hello, how are you?' }],
    model: 'llama3.2',  // Use any Ollama model you have installed
  })
  
  console.log(chatCompletion.choices[0].message.content)
  `);
}); 

#!/usr/bin/env node

// Test script for OpenAI compatibility layer
const express = require('express');
const { OllamaClient } = require('../dist');

console.log('🚀 Starting OpenAI compatibility test server...');

const app = express();
app.use(express.json());

// Create client
const client = new OllamaClient();

// Set up endpoints
console.log('⚙️  Setting up OpenAI compatibility endpoints...');

// Health check endpoint
app.get('/', (req, res) => {
  res.json({
    status: 'ok',
    message: 'Tekimax Ollama SDK - OpenAI Compatibility Layer',
    endpoints: [
      '/v1/chat/completions',
      '/v1/completions',
      '/v1/embeddings',
      '/v1/models',
      '/v1/models/{model}'
    ]
  });
});

// Setup all OpenAI compatible endpoints
client.openai.setupEndpoints(app)
  .then(() => {
    console.log('✅ OpenAI compatibility endpoints set up successfully');
    
    // Start server
    const port = process.env.PORT || 3000;
    app.listen(port, () => {
      console.log(`🔌 Server running at http://localhost:${port}`);
      console.log('');
      console.log('🧪 Test with curl:');
      console.log('---------------------');
      console.log(`curl http://localhost:${port}/v1/models`);
      console.log('');
      console.log(`curl http://localhost:${port}/v1/chat/completions \\`);
      console.log('  -H "Content-Type: application/json" \\');
      console.log('  -d \'{"model": "llama2", "messages": [{"role": "user", "content": "Hello!"}]}\'');
      console.log('');
      console.log('📚 For full documentation, see:');
      console.log('https://github.com/TEKIMAX/ollama-js-sdk#openai-compatibility');
    });
  })
  .catch(error => {
    console.error('❌ Failed to set up OpenAI compatibility endpoints:', error);
    process.exit(1);
  }); 

// Tool-calling example using @tekimax/ollama-sdk
const { OllamaClient } = require('../dist');

async function runToolExample() {
  console.log('📖 Ollama SDK Tool Calling Demo');
  console.log('============================\n');

  // Create an instance of the Ollama SDK
  const ollama = new OllamaClient();

  // Define a simple calculator tool
  const calculatorTool = {
    type: "function",
    name: "calculator",
    description: "A simple calculator that can add, subtract, multiply, and divide numbers",
    parameters: {
      type: "object",
      properties: {
        operation: {
          type: "string",
          enum: ["add", "subtract", "multiply", "divide"],
          description: "The operation to perform"
        },
        x: {
          type: "number",
          description: "The first number"
        },
        y: {
          type: "number",
          description: "The second number"
        }
      },
      required: ["operation", "x", "y"]
    }
  };

  // Define a weather lookup tool
  const weatherTool = {
    type: "function",
    name: "get_weather",
    description: "Get the current weather in a location",
    parameters: {
      type: "object",
      properties: {
        location: {
          type: "string",
          description: "The city and state, e.g., San Francisco, CA"
        },
        unit: {
          type: "string",
          enum: ["celsius", "fahrenheit"],
          description: "The unit of temperature"
        }
      },
      required: ["location"]
    }
  };

  try {
    // Call a model with the calculator tool
    console.log('🤖 Asking LLM to solve a math problem...\n');
    
    // Get the tools manager from the client
    const toolsManager = ollama.tools;
    
    const response = await toolsManager.callWithTools({
      model: "llama3",  // Make sure you have llama3 or another suitable model pulled
      prompt: "What is 24 * 15?",
      tools: [calculatorTool],
      temperature: 0.7
    });

    console.log('🔄 Model Response:');
    console.log(JSON.stringify(response.message, null, 2));
    console.log('\n');

    // If the model made tool calls, we would process them here
    if (response.message.tool_calls && response.message.tool_calls.length > 0) {
      const toolCall = response.message.tool_calls[0];
      console.log('🔧 Tool Call:');
      console.log(`Tool: ${toolCall.name}`);
      console.log(`Input: ${JSON.stringify(toolCall.input)}`);
      
      // Execute the calculator function
      let result;
      if (toolCall.name === 'calculator') {
        const { operation, x, y } = toolCall.input;
        
        switch(operation) {
          case 'add': result = x + y; break;
          case 'subtract': result = x - y; break;
          case 'multiply': result = x * y; break;
          case 'divide': result = x / y; break;
        }
        
        console.log(`Result: ${result}`);
        
        // Send the result back to the model
        const followUpResponse = await toolsManager.executeToolCalls(
          {
            model: "llama3",
            prompt: "What is 24 * 15?",
            tools: [calculatorTool]
          },
          [toolCall],
          [{ result }]
        );
        
        console.log('\n🤖 Follow-up Response:');
        console.log(followUpResponse.message.content);
      }
    } else {
      console.log('The model calculated the result directly without using tools.');
    }
    
  } catch (error) {
    console.error('Error:', error.message);
  }
}

// Run the example
runToolExample().catch(console.error); 

Getting Started

API Reference

Guides

Workshops & Tutorials

Installation

Prerequisites

Installing the SDK

Verify Installation

Installing the CLI (Optional)

Configuration

Troubleshooting

Future Model Support

Next Steps

Getting Started

API Reference

Guides

Workshops & Tutorials

​Prerequisites

​Installing the SDK

​Verify Installation

​Installing the CLI (Optional)

​Configuration

​Troubleshooting

​Future Model Support

​Next Steps