A TypeScript toolkit for integrating Large Language Models with tool execution capabilities.

A toolkit for integrating LLM applications with tool execution capabilities. Provides functionality for handling tool calls, managing chat sessions, and executing operations.

• 🎯 Clean API: Simple interface with minimal setup required
• 📐 Type Safety: Full TypeScript support with type definitions
• 📱 Session Management: Session handling with abort controls and permission inheritance
• 🧠 Context: System prompts with environment-aware ContextSys integration
• 🔧 Tool Execution: Tool registration with error handling and validation
• 🔒 Permission System: Approval controls for tool execution with approve, deny, and allow_all options
• 🛡️ Security: Security measures with tool usage restrictions and validation
• 🌊 Streaming Support: API for both streaming and standard responses
• ⚡ Event-Driven: Real-time callbacks for thinking, messages, tool calls, and results

sequenceDiagram
    participant User
    participant Orchestrator
    participant ContextSys
    participant ChatManager
    participant ToolExecutor
    participant LLM
    participant Tools

    User->>Orchestrator: Send chat request
    Orchestrator->>ContextSys: Get system prompt
    ContextSys-->>Orchestrator: Return context
    Orchestrator->>ChatManager: Add user message + system context
    Orchestrator->>LLM: Send request with tools
    LLM-->>Orchestrator: Response with tool calls

    loop For each tool call
        Orchestrator->>User: Request permission
        User-->>Orchestrator: Approve/Deny/Allow All
        alt Permission Granted
            Orchestrator->>ToolExecutor: Execute tool
            ToolExecutor->>Tools: Run tool logic
            Tools-->>ToolExecutor: Return result
            ToolExecutor-->>Orchestrator: Tool result
            Orchestrator->>ChatManager: Add tool result to session
        else Permission Denied
            Orchestrator->>User: Abort session
        end
    end

    Orchestrator->>LLM: Send updated context
    LLM-->>Orchestrator: Final response
    Orchestrator->>ChatManager: Add final message
    Orchestrator-->>User: Return session with abort capability

• Core: Tool execution logic and validation
• Integrator: Chat orchestration, session management, and permission handling
• Interfaces: TypeScript type definitions for all components
• Schemas: Tool schema definitions for LLM integration
• Utils: Utility functions for ID generation and common operations

1. 👤 Create Ollama Account

   • Sign up at ollama.com
   • Create an API key by visiting ollama.com/settings/keys

2. 📦 Clone Repository

   git clone https://github.com/NeaByteLab/LLM-Toolkit.git
   cd LLM-Toolkit

3. ⚙️ Environment Setup

   # Create environment file
   echo "OLLAMA_KEY=your_api_key_here" > .env
   
   # Edit .env and replace with your actual API key
   # OLLAMA_KEY=your_actual_api_key_here

4. 📦 Install Dependencies

   npm install

npx tsx ./src/index.ts

This demonstrates the complete toolkit with:

• Permission system (denies TerminalCmd, approves FileCreate/FileEdit)
• Streaming responses
• Auto-abort after 3 seconds
• All event callbacks

src/
├── schemas/                  # Tool schema definitions
├── core/
│   ├── base/                 # Tool implementation logic
│   └── ToolExecutor.ts       # Tool registration & execution

1. Create Schema (/src/schemas/YourTool.ts)

   export default {
     type: 'function',
     function: {
       name: 'your_tool_name',
       description: 'What your tool does',
       parameters: {
         type: 'object',
         properties: {
           param1: { type: 'string', description: 'Description' }
         },
         required: ['param1']
       }
     }
   }

2. Implement Logic (/src/core/base/YourTool.ts)

   export default class YourTool {
     private readonly param1: string
   
     constructor(args: SchemaYourTool) {
       const { param1 } = args
       this.param1 = param1
     }
   
     async execute(): Promise<string> {
       const resValidate = this.validate()
       if (resValidate !== 'ok') {
         return resValidate
       }
       // Your logic here
       return 'Success message'
     }
   
     private validate(): string {
       if (typeof this.param1 !== 'string') {
         return '`param1` must be a string.'
       }
       return 'ok'
     }
   }

3. Register in ToolExecutor.ts

   // Add import
   import YourTool from '@core/base/YourTool'
   import type { SchemaYourTool } from '@root/interfaces/index'
   
   // Add to switch statement
   case 'your_tool_name':
     return new YourTool(args as SchemaYourTool).execute()

To edit the AI's behavior and personality:

• 🔧 Modify getSystemPrompt() method
• ➕➖ Add/remove capabilities, guidelines, or instructions
• 🎭 Customize the AI agent's behavior and personality
• 🔒 Update security guidelines or tool usage rules

To edit the environment context:

• 🔧 Modify getContext() to change format or add/remove information
• ➕ Add new methods to gather additional system information
• ⏰ Customize time format in getTimeInfo()
• 💻 Add more OS details in getOSInfo()
• 📁 Include additional path information in getPathInfo()

The toolkit includes a permission system for controlling tool execution:

• approve: Allow this specific tool call
• deny: Block this tool call and abort session
• allow_all: Approve this call and all future calls in this session

const session = await orchestrator.chat(message, {
  onAskPermission: (data) => {
    console.log(`Permission requested for: ${data.toolName}`)

    // Custom permission logic
    if (data.toolName === 'TerminalCmd') {
      return { action: 'deny' } // Block terminal commands
    }

    return { action: 'approve' } // Allow everything else
  },
  // ... other options
})

// Abort specific session
session.abort()

// Check if session is active
const isActive = session.isActive()

// Abort all sessions
orchestrator.abort()

1. Auto-creation: Sessions are created when you call chat()
2. Context injection: System prompt is added on first message
3. Permission tracking: Session remembers "allow all" settings
4. Termination: Abort stops all operations

• Embedding README: Text vectorization and similarity search using transformer models
• Provides semantic search, text similarity, and content clustering capabilities
• Independent module for advanced text processing features

This project is licensed under the MIT license. See the LICENSE file for more info.