Agents Works

npm install node-telegram-bot-api dotenv

require('dotenv').config();
const TelegramBot = require('node-telegram-bot-api');

const token = process.env.TELEGRAM_BOT_TOKEN;
const bot = new TelegramBot(token, { polling: true });
const API_KEY = process.env.AGENTSWORKS_API_KEY;
const AGENT_ID = process.env.AGENT_ID;

// Хранилище контекста для каждого чата
const conversations = new Map();

// Функция вызова агента
async function callAgent(message, chatId) {
  try {
    // Получаем историю или создаем новую
    let history = conversations.get(chatId) || [];
    
    // Добавляем текущее сообщение
    history.push({ role: 'user', content: message });
    
    // Ограничиваем историю последними 20 сообщениями
    if (history.length > 20) {
      history = history.slice(-20);
    }
    
    const response = await fetch('https://agentsworks.ru/api/agents/v1/chat/completions', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${API_KEY}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        model: AGENT_ID,
        messages: history,
        agent_id: AGENT_ID,
        stream: false,
      }),
    });
    
    const data = await response.json();
    const agentResponse = data.choices[0].message.content;
    
    // Добавляем ответ агента в историю
    history.push({ role: 'assistant', content: agentResponse });
    conversations.set(chatId, history);
    
    return agentResponse;
  } catch (error) {
    console.error('Error calling agent:', error);
    throw error;
  }
}

// Обработка текстовых сообщений
bot.on('message', async (msg) => {
  const chatId = msg.chat.id;
  const userMessage = msg.text;
  
  if (!userMessage) return; // Игнорируем не текстовые сообщения
  
  console.log(`[${chatId}] User: ${userMessage}`);
  
  try {
    // Отправляем индикатор "печатает"
    await bot.sendChatAction(chatId, 'typing');
    
    // Вызываем агента
    const response = await callAgent(userMessage, chatId);
    
    // Отправляем ответ
    await bot.sendMessage(chatId, response);
    console.log(`[${chatId}] Bot: ${response.substring(0, 50)}...`);
    
  } catch (error) {
    console.error('Error:', error);
    await bot.sendMessage(
      chatId, 
      'Извините, произошла ошибка. Попробуйте позже.'
    );
  }
});

// Команда /start
bot.onText(/\/start/, async (msg) => {
  const chatId = msg.chat.id;
  await bot.sendMessage(
    chatId,
    'Привет! Я ИИ-ассистент, готовый помочь с вопросами по продукту. '
    'Просто напишите мне сообщение!'
  );
});

// Команда /help
bot.onText(/\/help/, async (msg) => {
  const chatId = msg.chat.id;
  await bot.sendMessage(
    chatId,
    'Доступные команды:\n'
    '/start — начать диалог\n'
    '/help — справка\n'
    '/clear — очистить историю диалога'
  );
});

// Команда /clear
bot.onText(/\/clear/, (msg) => {
  const chatId = msg.chat.id;
  conversations.delete(chatId);
  bot.sendMessage(chatId, 'История диалога очищена. Начнем сначала!');
});

console.log('Bot is running...');

node bot.js

pip install aiogram python-dotenv

import os
import asyncio
from dotenv import load_dotenv
from aiogram import Bot, Dispatcher, types
from aiogram.filters import Command
import requests

load_dotenv()

TOKEN = os.getenv("TELEGRAM_BOT_TOKEN")
API_KEY = os.getenv("AGENTSWORKS_API_KEY")
AGENT_ID = os.getenv("AGENT_ID")

bot = Bot(token=TOKEN)
dp = Dispatcher()

# Хранилище контекста
conversations = {}

def call_agent(message: str, chat_id: int) -> str:
    """Вызов ИИ-агента через API"""
    
    # Получаем или создаем историю
    history = conversations.get(chat_id, [])
    
    # Добавляем текущее сообщение
    history.append({"role": "user", "content": message})
    
    # Ограничиваем историю
    if len(history) > 20:
        history = history[-20:]
    
    response = requests.post(
        'https://agentsworks.ru/api/agents/v1/chat/completions',
        headers={
            'Authorization': f'Bearer {API_KEY}',
            'Content-Type': 'application/json',
        },
        json={
            'model': AGENT_ID,
            'messages': history,
            'agent_id': AGENT_ID,
            'stream': False,
        }
    )
    
    data = response.json()
    agent_response = data['choices'][0]['message']['content']
    
    # Добавляем ответ в историю
    history.append({"role": "assistant", "content": agent_response})
    conversations[chat_id] = history
    
    return agent_response

@dp.message(Command("start"))
async def cmd_start(message: types.Message):
    await message.answer(
        "Привет! Я ИИ-ассистент, готовый помочь с вопросами по продукту. "
        "Просто напишите мне сообщение!"
    )

@dp.message(Command("help"))
async def cmd_help(message: types.Message):
    await message.answer(
        "Доступные команды:\n"
        "/start — начать диалог\n"
        "/help — справка\n"
        "/clear — очистить историю диалога"
    )

@dp.message(Command("clear"))
async def cmd_clear(message: types.Message):
    chat_id = message.chat.id
    if chat_id in conversations:
        del conversations[chat_id]
    await message.answer("История диалога очищена. Начнем сначала!")

@dp.message()
async def handle_message(message: types.Message):
    chat_id = message.chat.id
    user_message = message.text
    
    if not user_message:
        return
    
    # Отправляем индикатор "печатает"
    await bot.send_chat_action(chat_id, 'typing')
    
    try:
        # Вызываем агента
        response = call_agent(user_message, chat_id)
        
        # Отправляем ответ
        await message.answer(response)
        
    except Exception as e:
        print(f"Error: {e}")
        await message.answer(
            "Извините, произошла ошибка. Попробуйте позже."
        )

async def main():
    print("Bot is running...")
    await dp.start_polling(bot)

if __name__ == "__main__":
    asyncio.run(main())

python bot.py

const express = require('express');
const TelegramBot = require('node-telegram-bot-api');
require('dotenv').config();

const token = process.env.TELEGRAM_BOT_TOKEN;
const bot = new TelegramBot(token);
const app = express();
const PORT = process.env.PORT || 3000;

const WEBHOOK_URL = process.env.WEBHOOK_URL + '/webhook';

// Устанавливаем webhook
bot.setWebHook(WEBHOOK_URL).then(() => {
  console.log(`Webhook set to ${WEBHOOK_URL}`);
});

// Обработка webhook
app.post('/webhook', (req, res) => {
  bot.processUpdate(req.body);
  res.sendStatus(200);
});

// ... ваш код обработки сообщений

app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});

pip install slack-bolt python-dotenv

import os
from dotenv import load_dotenv
from slack_bolt import App
from slack_bolt.adapter.socket_mode import SocketModeHandler
import requests

load_dotenv()

# Инициализация Slack-бота
app = App(
    token=os.environ.get("SLACK_BOT_TOKEN"),
    signing_secret=os.environ.get("SLACK_SIGNING_SECRET")
)

API_KEY = os.environ.get("AGENTSWORKS_API_KEY")
AGENT_ID = os.environ.get("AGENT_ID")

# Хранилище контекста
conversations = {}

def call_agent(message: str, channel_id: str) -> str:
    """Вызов ИИ-агента через API"""
    
    # Получаем или создаем историю
    history = conversations.get(channel_id, [])
    
    # Добавляем текущее сообщение
    history.append({"role": "user", "content": message})
    
    # Ограничиваем историю
    if len(history) > 20:
        history = history[-20:]
    
    response = requests.post(
        'https://agentsworks.ru/api/agents/v1/chat/completions',
        headers={
            'Authorization': f'Bearer {API_KEY}',
            'Content-Type': 'application/json',
        },
        json={
            'model': AGENT_ID,
            'messages': history,
            'agent_id': AGENT_ID,
            'stream': False,
        }
    )
    
    data = response.json()
    agent_response = data['choices'][0]['message']['content']
    
    # Добавляем ответ в историю
    history.append({"role": "assistant", "content": agent_response})
    conversations[channel_id] = history
    
    return agent_response

# Обработка упоминаний бота
@app.event("app_mention")
def handle_mention(event, say):
    """Обработка упоминания бота в канале"""
    user_message = event.get("text", "")
    channel_id = event.get("channel")
    bot_id = event.get("bot_id")
    
    # Удаляем упоминание бота из сообщения
    message = user_message.replace(f"<@{bot_id}>", "").strip()
    
    if not message:
        return
    
    try:
        # Вызываем агента
        response = call_agent(message, channel_id)
        
        # Отправляем ответ
        say(text=response)
        
    except Exception as e:
        print(f"Error: {e}")
        say(text="Извините, произошла ошибка. Попробуйте позже.")

# Обработка сообщений в личных сообщениях
@app.message()
def handle_direct_message(message, say):
    """Обработка личных сообщений боту"""
    channel_type = message.get("channel_type")
    
    # Обрабатываем только личные сообщения
    if channel_type != "im":
        return
    
    user_message = message.get("text", "")
    channel_id = message.get("channel")
    
    if not user_message:
        return
    
    try:
        # Вызываем агента
        response = call_agent(user_message, channel_id)
        
        # Отправляем ответ
        say(text=response)
        
    except Exception as e:
        print(f"Error: {e}")
        say(text="Извините, произошла ошибка. Попробуйте позже.")

# Слэш-команда /ask
@app.command("/ask")
def handle_ask_command(ack, body, respond):
    """Слэш-команда для запроса к агенту"""
    ack()
    
    user_message = body.get("text", "")
    channel_id = body.get("channel_id")
    
    if not user_message:
        respond(text="Пожалуйста, укажите ваш запрос после /ask")
        return
    
    try:
        # Вызываем агента
        response = call_agent(user_message, channel_id)
        
        # Отправляем ответ
        respond(text=response)
        
    except Exception as e:
        print(f"Error: {e}")
        respond(text="Извините, произошла ошибка. Попробуйте позже.")

# Запуск бота
if __name__ == "__main__":
    handler = SocketModeHandler(
        app, 
        os.environ.get("SLACK_APP_TOKEN")
    )
    handler.start()

python slack_bot.py

bot.onText(/\/menu/, async (msg) => {
  const chatId = msg.chat.id;
  
  const keyboard = {
    reply_markup: {
      inline_keyboard: [
        [
          { text: '📚 Документация', callback_data: 'docs' },
          { text: '💬 Поддержка', callback_data: 'support' }
        ],
        [
          { text: '💰 Тарифы', callback_data: 'pricing' },
          { text: '📞 Контакты', callback_data: 'contacts' }
        ]
      ]
    }
  };
  
  await bot.sendMessage(
    chatId,
    'Что вас интересует?',
    keyboard
  );
});

// Обработка нажатий на кнопки
bot.on('callback_query', async (query) => {
  const chatId = query.message.chat.id;
  const data = query.data;
  
  let question = '';
  switch (data) {
    case 'docs': question = 'Расскажи о документации'; break;
    case 'support': question = 'Как связаться с поддержкой?'; break;
    case 'pricing': question = 'Какие тарифы доступны?'; break;
    case 'contacts': question = 'Контакты компании'; break;
  }
  
  const response = await callAgent(question, chatId);
  await bot.sendMessage(chatId, response);
  
  await bot.answerCallbackQuery(query.id);
});

from slack_sdk import WebClient

client = WebClient(token=os.environ.get("SLACK_BOT_TOKEN"))

def send_buttons(channel):
    """Отправка кнопок в Slack"""
    blocks = [
        {
            "type": "section",
            "text": {
                "type": "mrkdwn",
                "text": "Что вас интересует?"
            },
            "accessory": {
                "type": "static_select",
                "placeholder": {
                    "type": "plain_text",
                    "text": "Выберите вариант"
                },
                "options": [
                    {
                        "text": {
                            "type": "plain_text",
                            "text": "📚 Документация"
                        },
                        "value": "docs"
                    },
                    {
                        "text": {
                            "type": "plain_text",
                            "text": "💬 Поддержка"
                        },
                        "value": "support"
                    },
                    {
                        "text": {
                            "type": "plain_text",
                            "text": "💰 Тарифы"
                        },
                        "value": "pricing"
                    }
                ]
            }
        }
    ]
    
    client.chat_postMessage(
        channel=channel,
        blocks=blocks
    )

import redis
import json

# Подключение к Redis
redis_client = redis.Redis(host='localhost', port=6379, db=0)

def get_history(chat_id: str) -> list:
    """Получение истории из Redis"""
    data = redis_client.get(f"history:{chat_id}")
    if data:
        return json.loads(data)
    return []

def save_history(chat_id: str, history: list):
    """Сохранение истории в Redis"""
    redis_client.setex(
        f"history:{chat_id}", 
        3600,  # 1 час TTL
        json.dumps(history)
    )

def call_agent(message: str, chat_id: str) -> str:
    """Вызов агента с сохранением в Redis"""
    
    # Получаем историю из Redis
    history = get_history(chat_id)
    
    # Добавляем сообщение
    history.append({"role": "user", "content": message})
    
    # Ограничиваем историю
    if len(history) > 20:
        history = history[-20:]
    
    # Вызов агента
    response = requests.post(
        'https://agentsworks.ru/api/agents/v1/chat/completions',
        headers={
            'Authorization': f'Bearer {API_KEY}',
            'Content-Type': 'application/json',
        },
        json={
            'model': AGENT_ID,
            'messages': history,
            'agent_id': AGENT_ID,
            'stream': False,
        }
    )
    
    data = response.json()
    agent_response = data['choices'][0]['message']['content']
    
    # Добавляем ответ
    history.append({"role": "assistant", "content": agent_response})
    
    # Сохраняем в Redis
    save_history(chat_id, history)
    
    return agent_response

MAX_MESSAGE_LENGTH = 4096  # для Telegram

def split_message(text: str, max_length: int = MAX_MESSAGE_LENGTH) -> list:
    """Разделение длинного сообщения на части"""
    if len(text) <= max_length:
        return [text]
    
    parts = []
    current_part = ""
    
    # Разбиваем по строкам
    for line in text.split('\n'):
        if len(current_part) + len(line) + 1 <= max_length:
            current_part += line + '\n'
        else:
            if current_part:
                parts.append(current_part.strip())
            current_part = line + '\n'
    
    if current_part:
        parts.append(current_part.strip())
    
    return parts

# Использование
response = call_agent(user_message, chat_id)
for part in split_message(response):
    await message.answer(part)

// Отправляем "печатает"
await bot.sendChatAction(chatId, 'typing');

// Или для задержки
await bot.sendChatAction(chatId, 'upload_photo');

from slack_sdk import WebClient
import time

client = WebClient(token=os.environ.get("SLACK_BOT_TOKEN"))

# Отправляем сообщение с индикатором загрузки
response = client.chat_postMessage(
    channel=channel,
    text="🤔 Думаю..."
)

timestamp = response["message"]["ts"]

# Получаем ответ от агента
agent_response = call_agent(user_message, channel)

# Обновляем сообщение
client.chat_update(
    channel=channel,
    ts=timestamp,
    text=agent_response
)

import logging
from datetime import datetime

# Настройка логирования
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    filename='bot.log'
)

logger = logging.getLogger(__name__)

# Использование
logger.info(f"[{chat_id}] User: {user_message}")
logger.info(f"[{chat_id}] Bot: {response[:50]}...")

// Express сервер с health check
const express = require('express');
const app = express();

app.get('/health', (req, res) => {
  res.status(200).json({
    status: 'ok',
    timestamp: new Date().toISOString(),
    uptime: process.uptime()
  });
});

app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});