DEV Community: Ibrohim Abdivokhidov

Intro to Python core, Epam Data Software Engineering training

Ibrohim Abdivokhidov — Sat, 27 Dec 2025 21:20:31 +0000

In this tutorial I have explained orally the beginning of Python Core module from Epam’s Data Software Engineering Course.

In this tutorial I have covered following:

Module Introduction
Types of Programming Languages
Introduction to Python
Interactive Python
Python Installation
PyCharm Installation
Git Installation and Configuration
GitLab
Data Types Overview
Numbers
Boolean and Comparison Operator
Loops

Tutorials
But what are the Python functions?

But what is DevOps? | DevOps in short yet clear

But what are the Python functions?

OOP in Python

Data Warehouse Theory

Deep Dive Into Data and Databases, Data Warehouses, Database Management, Database Modeling and more

What is Data Engineering?

Data Engineering Lifecycle

Data Engineering Lifecycle. Undercurrents

Big Data Concept

Data Characteristics

Github: https://github.com/TechWithAbee/Epam

How to build CLI AI Agent with OpenAI Responses API + Zapier MCP

Ibrohim Abdivokhidov — Wed, 22 Oct 2025 08:59:11 +0000

CLI Agent (OpenAI Responses + Zapier MCP)

A terminal chat UI that uses the OpenAI Responses API with Zapier MCP tools. Shows an ASCII banner on launch and provides a simple, chat-like experience with commands for help, powers, examples, clearing the screen, and exit.

Watch on YouTube:

Features

Chat-style CLI with wrapped output and optional colors
Zapier MCP integration (tool_choice: required) to perform actions across:
- Google Docs, Google Sheets, Google Calendar, Google Meet, Google Drive, Google Forms, Gmail, Telegram, WhatsApp
ASCII banner on launch (optional)

Screenshots (Live Demo)

todo-list

terminal-chat-1

terminal-chat-2

terminal-chat-3

google-calendar

gmail-google-meet

gmail-invitation

telegram-chat

google-docs

zapier-dashboard-1

zapier-dashboard-2

google-sheets-responses

Step-by-step tutorial

1) Check prerequisites

Python 3.9+ installed
Two API keys available: OPENAI_API_KEY and ZAPIER_MCP_API_KEY

2) (Optional) Create and activate a virtual environment

python3 -m venv .venv
source .venv/bin/activate

3) Install dependencies

pip install openai python-dotenv art colorama

4) Configure environment variables

Option A (macOS/Linux):

export OPENAI_API_KEY=sk-...
export ZAPIER_MCP_API_KEY=...

Option B (.env file in project root; auto-loaded if python-dotenv is installed):

OPENAI_API_KEY=sk-...
ZAPIER_MCP_API_KEY=...

5) Ensure your Zapier MCP account has access to the apps you plan to use

At minimum, connect Gmail and Google Calendar for the meeting demo
Optionally connect Google Docs, Sheets, Drive, Forms, Telegram, WhatsApp

6) Run the CLI

python main.py

When prompted, optionally enter your display name
Useful commands: /help, /powers, /examples, /clear, /exit

7) Try a quick workflow

Schedule a meeting and email the attendee:

Schedule a Google Meet on 20 Oct 2025, 10:00–11:00 with John Doe.
My email abdibrokhim@gmail.com, his email theelofiguy@gmail.com.
Send him a short, casual invite email about this coffee chat.

Create a project brief in Docs:

Create a Google Doc titled “Project Zap” with sections: Overview, Goals, Timeline, Risks.
Share with ops@acme.com.

Start a budget in Sheets:

Create a budget Google Sheet with columns: Item, Cost, Owner. Add three sample rows.

8) Tips

The CLI uses tool_choice="required" so the model will actually call Zapier MCP tools
If art or colorama aren’t installed, the app falls back to plain output
You can paste transcripts/notes after a meeting and ask: “Summarize and save to Google Docs”

9) Troubleshooting

See the Troubleshooting section below for common issues

Requirements

Python 3.9+
Packages:
- Required: openai
- Optional: python-dotenv (load .env), art (ASCII banner), colorama (colors)

Install:

pip install openai python-dotenv art colorama

Environment variables

export OPENAI_API_KEY=sk-...
export ZAPIER_MCP_API_KEY=...

If you prefer, create a .env file with these keys; the app will attempt to load it if python-dotenv is installed.

Run

python main.py

On start you can optionally enter your display name. Use commands during chat:

/help – show help
/powers – list available integrations and abilities
/examples – sample prompts
/clear – clear the screen
/exit – quit

Example prompt

Schedule a meeting and send an invite:

Schedule a Google Meet on 20 Oct 2025, 10:00–11:00 with John Doe.
My email abdibrokhim@gmail.com, his email theelofiguy@gmail.com.
Send him a short, casual invite email about this coffee chat.

Notes

The CLI uses tool_choice="required" so the model will call Zapier MCP tools to complete tasks.
If art or colorama aren’t installed, the app gracefully falls back to plain output.

Troubleshooting

"OPENAI_API_KEY is not set" – export it as shown above.
"ZAPIER_MCP_API_KEY is not set" – export your Zapier MCP API key.
If no ASCII banner appears, install art, or ignore (optional).

Sora 2 / Sora 2 Pro Python CLI

Ibrohim Abdivokhidov — Wed, 08 Oct 2025 14:59:06 +0000

Sora 2 / Sora 2 Pro Video CLI

Command-line client for OpenAI's Sora 2 and Sora 2 Pro video generation API, implemented in Python (main.py). Supports creating videos (text-only or image-guided), polling, downloading content, listing, retrieving, deleting, and remixing.

Features

Models: sora-2 and sora-2-pro
Create: text prompt, resolution, duration; optional image reference via multipart upload
Status: retrieve and poll with configurable interval and timeout
Content: download MP4 upon completion
Manage: list, delete, remix existing videos
Resilience: retries and backoff on transient errors; clear JSON errors
Auth: OPENAI_API_KEY env var; optional .env support

*Note: Reference image should be specific size.

Requirements

Python 3.9+
Dependencies:
- Standard library only for HTTP
- Optional: python-dotenv if you want .env loading

Install optional dependency:

pip install python-dotenv

Environment and Auth

Set your OpenAI API key as an environment variable or in a .env file at the project root.

export OPENAI_API_KEY="sk-..."

Or create a .env file:

echo 'OPENAI_API_KEY=sk-...' > .env

You can also pass --api-key to any command to override the environment.

Quick Start

Create a 4-second 720p clip with Sora 2:

python main.py create \
  --model sora-2 \
  --prompt "A cat does a backflip" \
  --size 1280x720 \
  --seconds 4

Create an image-guided clip (first frame from an image):

python main.py create \
  --model sora-2-pro \
  --prompt "Logo reveal with mist" \
  --size 1280x720 \
  --seconds 4 \
  --input-reference assets/worker.png

Poll until completion and download when ready:

python main.py poll vid_123 --download -o output.mp4

Download content directly:

python main.py download vid_123 -o output.mp4

List, retrieve, and delete:

python main.py list --limit 10
python main.py retrieve vid_123
python main.py delete vid_123

Remix an existing video with a new prompt:

python main.py remix vid_123 \
  --prompt "Change the background to a starry night sky." \
  --size 1280x720 \
  --seconds 8

Arguments and Validation

Models: sora-2, sora-2-pro
Durations: 4, 8, 12 seconds
Sizes:
- sora-2: 1280x720, 720x1280
- sora-2-pro: 1280x720, 720x1280, 1792x1024, 1024x1792

Invalid combinations will produce a helpful error message before the request is sent.

Base URL Override

Defaults to https://api.openai.com. Override with --base-url if you need a different API host.

python main.py create --base-url https://api.openai.com --model sora-2 ...

Exit Codes

0: success
1: API or validation error
124: poll timed out

Troubleshooting

400 errors: verify model, size, seconds, and that prompts follow content policy
401/403: ensure OPENAI_API_KEY is set and valid
429: client retries with backoff; consider lowering RPM or waiting
Multipart image: ensure the path exists and is a supported image type

Notes

Pricing and access to Sora 2 / Pro depend on your OpenAI account and tier.
For long-running workflows, prefer poll with --download or set up webhooks in your OpenAI account (when available) to avoid polling.

What is JWT? How do Secret, Public, Private Keys actually work?

Ibrohim Abdivokhidov — Sun, 14 Sep 2025 22:27:44 +0000

This guide covers two JWT authentication approaches for the English-Uzbek Translator API:

Secret Key + JWT (Symmetric - Traditional approach)
Public + Private Key (Asymmetric - Current implementation)

📋 Table of Contents

Overview
Approach 1: Secret Key + JWT
Approach 2: Public + Private Key
Comparison
Best Practices
Troubleshooting

Overview

What is JWT?

JSON Web Tokens (JWT) are a secure way to transmit information between parties. A JWT consists of three parts:

Header: Algorithm and token type
Payload: Claims (user data)
Signature: Verification signature

Authentication Flow

Both approaches follow the same basic flow:

Client obtains a JWT token
Client includes token in API requests
Server verifies token and processes request

Approach 1: Secret Key + JWT

🔍 When to Use

Single application environment
Centralized token generation (same server creates and verifies)
Simple deployment scenarios
Internal APIs within same organization

🛠️ Setup

Step 1: Generate Secret Key

# Generate a secure secret key
node -e "console.log(require('crypto').randomBytes(64).toString('hex'))"

Step 2: Configure Environment

# .env file
JWT_SECRET=your_64_character_secret_key_here
JWT_EXPIRES_IN=24h
JWT_ALGORITHM=HS256

Step 3: Server Configuration

// authService.js (Secret Key approach)
import jwt from 'jsonwebtoken';

const JWT_SECRET = process.env.JWT_SECRET;
const JWT_ALGORITHM = 'HS256';

class AuthService {
  // Generate token
  generateToken(user) {
    return jwt.sign(
      { 
        sub: user.id,
        username: user.username,
        iat: Math.floor(Date.now() / 1000)
      },
      JWT_SECRET,
      { 
        expiresIn: process.env.JWT_EXPIRES_IN || '24h',
        algorithm: JWT_ALGORITHM 
      }
    );
  }

  // Verify token
  verifyToken(token) {
    return jwt.verify(token, JWT_SECRET, { algorithms: [JWT_ALGORITHM] });
  }
}

🔐 Token Generation Example

// Example: Creating a JWT token (server-side)
const authService = new AuthService();

const user = {
  id: "user123",
  username: "john_doe"
};

const token = authService.generateToken(user);
console.log("Generated Token:", token);

// Output: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyMTIzIiwidXNlcm5hbWUiOiJqb2huX2RvZSIsImlhdCI6MTY0MjAwMDAwMCwiZXhwIjoxNjQyMDg2NDAwfQ.signature

📡 Making API Requests

# Using curl
curl -X POST http://localhost:8000/translate \
  -H "Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..." \
  -H "Content-Type: application/json" \
  -d '{"text": "Hello world"}'

// Using JavaScript/Node.js
const response = await fetch('http://localhost:8000/translate', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${token}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({ text: 'Hello world' })
});

Approach 2: Public + Private Key

🔍 When to Use (Current Implementation)

Distributed systems (microservices)
Third-party integration
Enhanced security requirements
Token generation separation from verification
Multiple token issuers

🛠️ Setup

Step 1: Generate RSA Key Pair

# Using the provided generator
npm run generate-keys

# Or manually with OpenSSL
openssl genrsa -out jwt-private.key 2048
openssl rsa -in jwt-private.key -pubout -out jwt-public.key

Step 2: Configure Environment

# .env file
JWT_PUBLIC_KEY="-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA...
-----END PUBLIC KEY-----"
JWT_ALGORITHM=RS256

Step 3: Server Configuration (Current)

// authService.js (Public Key approach - current implementation)
import jwt from 'jsonwebtoken';

const JWT_PUBLIC_KEY = process.env.JWT_PUBLIC_KEY;
const JWT_ALGORITHM = process.env.JWT_ALGORITHM || 'RS256';

class AuthService {
  constructor() {
    this.jwtPublicKey = this.loadPublicKey();
  }

  loadPublicKey() {
    if (process.env.JWT_PUBLIC_KEY) {
      return process.env.JWT_PUBLIC_KEY.replace(/\\n/g, '\n');
    }
    console.warn('⚠️  WARNING: No JWT public key found!');
    return null;
  }

  // Only verify tokens (no generation on server)
  verifyToken(token) {
    return new Promise((resolve, reject) => {
      jwt.verify(token, this.jwtPublicKey, { algorithms: [this.jwtAlgorithm] }, (err, decoded) => {
        if (err) reject(err);
        else resolve(decoded);
      });
    });
  }
}

🔐 Token Generation (External)

Important: With public/private key approach, tokens are generated externally using the private key.

Using Node.js

// external-token-generator.js
import jwt from 'jsonwebtoken';
import fs from 'fs';

const privateKey = fs.readFileSync('./jwt-private.key', 'utf8');

function generateToken(user) {
  const payload = {
    sub: user.id,
    username: user.username,
    iat: Math.floor(Date.now() / 1000),
    exp: Math.floor(Date.now() / 1000) + (24 * 60 * 60) // 24 hours
  };

  return jwt.sign(payload, privateKey, { algorithm: 'RS256' });
}

// Example usage
const user = { id: "user123", username: "john_doe" };
const token = generateToken(user);
console.log("Generated Token:", token);

Using Python

# external_token_generator.py
import jwt
import time
from cryptography.hazmat.primitives import serialization

# Load private key
with open('./jwt-private.key', 'rb') as f:
    private_key = serialization.load_pem_private_key(
        f.read(),
        password=None
    )

def generate_token(user_id, username):
    payload = {
        'sub': user_id,
        'username': username,
        'iat': int(time.time()),
        'exp': int(time.time()) + (24 * 60 * 60)  # 24 hours
    }

    return jwt.encode(payload, private_key, algorithm='RS256')

# Example usage
token = generate_token("user123", "john_doe")
print(f"Generated Token: {token}")

Using JWT.io (Manual)

Go to jwt.io
Select RS256 algorithm
Enter your payload:

{
  "sub": "user123",
  "username": "john_doe",
  "iat": 1642000000,
  "exp": 1642086400
}

Paste your private key in the "Private Key" field
Copy the generated token

📡 Making API Requests

# Check auth status
curl http://localhost:8000/auth/status

# Verify your token
curl -X GET http://localhost:8000/auth/verify \
  -H "Authorization: Bearer eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9..."

# Make translation request
curl -X POST http://localhost:8000/translate \
  -H "Authorization: Bearer eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9..." \
  -H "Content-Type: application/json" \
  -d '{"text": "Hello world"}'

🧪 Testing

# Run the test suite with your token
JWT_TOKEN="your_generated_token_here" npm run test-auth

# Test the client
JWT_TOKEN="your_generated_token_here" node jwt-client.js

Comparison

Feature	Secret Key + JWT	Public + Private Key
Security	Symmetric (shared secret)	Asymmetric (separate keys)
Token Generation	Server-side	External/Client-side
Key Management	Single secret key	Public key on server, private key secure
Scalability	Limited to single service	Distributed systems friendly
Complexity	Simple	More complex
Use Case	Internal APIs	Third-party integrations
Algorithm	HS256	RS256

Security Considerations

Secret Key Approach

✅ Simple implementation
✅ Fast verification
❌ Shared secret vulnerability
❌ Key rotation complexity

Public/Private Key Approach

✅ No shared secrets
✅ Easy key rotation
✅ Distributed token generation
❌ Slightly slower verification
❌ More complex setup

Best Practices

🔐 Security

Never commit private keys to version control
Use environment variables for sensitive data
Implement token expiration (reasonable timeframes)
Validate all JWT claims (exp, iat, sub, etc.)
Use HTTPS in production
Implement rate limiting for authentication endpoints

🗂️ Key Management

# Add to .gitignore
echo "jwt-private.key" >> .gitignore
echo ".env" >> .gitignore

# Set proper file permissions
chmod 600 jwt-private.key  # Private key - owner read/write only
chmod 644 jwt-public.key   # Public key - readable by others

🏗️ Token Structure

Recommended JWT payload structure:

{
  "sub": "user_unique_identifier",
  "username": "human_readable_name", 
  "iat": 1642000000,
  "exp": 1642086400,
  "roles": ["user", "translator"],
  "permissions": ["read", "translate"]
}

🔄 Token Refresh

// Check token expiration before requests
function isTokenExpired(token) {
  try {
    const decoded = jwt.decode(token);
    return decoded.exp < Date.now() / 1000;
  } catch (error) {
    return true;
  }
}

// Auto-refresh logic
if (isTokenExpired(currentToken)) {
  currentToken = await generateNewToken();
}

Troubleshooting

Common Issues

1. "JWT public key not configured"

# Solution: Set the public key in environment
export JWT_PUBLIC_KEY="-----BEGIN PUBLIC KEY-----..."

2. "Token verification failed"

# Check algorithm mismatch
# Ensure your token is signed with RS256 for public/private key approach
# Ensure your token is signed with HS256 for secret key approach

3. "Token expired"

// Check token expiration
const decoded = jwt.decode(token);
console.log('Token expires at:', new Date(decoded.exp * 1000));

4. "Invalid signature"

# Ensure you're using the correct private key for signing
# Verify the public key matches the private key used for signing
openssl rsa -in jwt-private.key -pubout | diff - jwt-public.key

Debug Mode

# Enable debug logging
DEBUG=jwt* npm start

# Check token details without verification
node -e "console.log(JSON.stringify(require('jsonwebtoken').decode('your_token_here'), null, 2))"

Testing Endpoints

# Health check (no auth required)
curl http://localhost:8000/health

# Auth status
curl http://localhost:8000/auth/status

# Token verification
curl -H "Authorization: Bearer YOUR_TOKEN" http://localhost:8000/auth/verify

🎯 Next Steps

Choose your approach based on your requirements
Generate appropriate keys (secret or RSA pair)
Configure environment variables
Test token generation and verification
Implement in your application
Set up monitoring and logging

Production Checklist

[ ] Keys stored securely (env vars, key management service)
[ ] Private keys never on server (public/private approach)
[ ] HTTPS enabled
[ ] Token expiration configured
[ ] Rate limiting implemented
[ ] Logging and monitoring set up
[ ] Error handling implemented
[ ] Documentation updated

This tutorial covers both JWT authentication approaches. Choose the one that best fits your architecture and security requirements.

How I Built AI Conversational Agents with Tool Calling for English Learning Apps (e.g., englify.uz)

Ibrohim Abdivokhidov — Sun, 14 Sep 2025 10:32:20 +0000

Liquid syntax error: Variable '{{% raw %}' was not properly terminated with regexp: /\}\}/

ANORA Is Nuts. Higgsfield AI Killer Just Dropped Huge Update.

Ibrohim Abdivokhidov — Thu, 28 Aug 2025 18:03:11 +0000

Anora posters are now live in subways for the next a couple of weeks/months/years, whatever. lol

welcome back to school everyone!

comment “gf” and Anora (she) will dm u exactly how much this costs + who our hacker was

btw; use this code 00000 and get extra 500000 credits

try now at https://anora.yaps.gg/projects it’s totally FREE!!

LinkedIn post: https://www.linkedin.com/posts/abdibrokhim_anora-posters-are-now-live-in-subways-for-activity-7366888379843600384-koAV

Integrating Keywords AI into AI Agentic Apps 🧵

Ibrohim Abdivokhidov — Thu, 26 Jun 2025 15:24:47 +0000

Integrating Keywords AI into AI Agentic Apps 🧵

Give Your AI Agents Enterprise-Grade Observability with Keywords AI 📊🤖

🚀 Building AI agents but struggling to monitor their performance? Here's how I integrated @KeywordsAI into my AI agent system to get enterprise-grade observability, analytics, and cost tracking.

The result? Complete visibility into every AI interaction! 🧵👇

🤔 The Problem: AI agents are black boxes. You can't see what prompts they're using, how much they cost, which models perform best, or why they sometimes fail.

Solution: Keywords AI = Complete LLM observability with logs, metrics, and analytics! 📈

📊 Keywords AI gives you everything you need to monitor AI agents:
• Complete request/response logging
• Real-time cost tracking
• Performance metrics
• Error debugging
• User analytics
• Model comparison

All in one beautiful dashboard! ✨

🛠️ Integration is incredibly simple. Just update your OpenAI client to use Keywords AI proxy:

const openai = new OpenAI({
  baseURL: "https://api.keywordsai.co/api",
  apiKey: process.env.KEYWORDS_AI_API_KEY
});

That's it! All requests are now automatically logged! 🎯

💡 But here's where it gets powerful - Keywords AI service class for advanced tracking:

export class KeywordsAIService {
  getCompletionParams(userId, conversationId, metadata) {
    return {
      customer_identifier: userId || 'anonymous_user',
      thread_id: conversationId || `conversation_${Date.now()}`,
      customer_user_id: userId,
      ...metadata
    };
  }
}

🎯 Enhanced completion requests with user tracking:

const keywordsAIParams = keywordsAIService.getCompletionParams(
  userId,
  userCache?.conversationId,
  { source: 'wei-ai-assistant' }
);

const completion = await openai.chat.completions.create({
  model,
  messages,
  ...keywordsAIParams  // Magic happens here!
});

📈 The real power comes from event tracking. Here's how I track different AI agent operations:

// Track memory operations
await keywordsAIService.trackMemoryOperation(userId, 'search', metadata);

// Track search operations  
await keywordsAIService.trackSearchOperation(userId, 'web', query, resultsCount);

// Track agent interactions
await keywordsAIService.trackAgentInteraction(userId, agentName, 'function_call');

🔍 Real-time monitoring in action:

User asks AI agent a question
Agent calls multiple functions (memory, search, tools)
Each operation is automatically logged
Keywords AI dashboard shows complete conversation flow
You can debug issues in real-time!

Perfect for production! 🚀

⚡ Advanced tracking features I'm using:

async trackHabitCompletion(userId, habitId, habitName, pointsEarned) {
  await this.trackEvent('habit_completed', userId, {
    habit_id: habitId,
    habit_name: habitName,
    points_earned: pointsEarned,
    category: 'wellness'
  });
}

Custom events for business-specific analytics! 📊

🛡️ Error handling and health monitoring:

async getHealthStatus() {
  try {
    const response = await fetch(`${this.config.baseURL}/health`, {
      headers: { 'Authorization': `Bearer ${this.config.apiKey}` }
    });
    return response.ok ? 
      { status: 'healthy', message: 'Keywords AI operational' } :
      { status: 'error', message: `API responded with ${response.status}` };
  } catch (error) {
    return { status: 'error', message: `Connection failed: ${error.message}` };
  }
}

📊 What you get in the Keywords AI dashboard:

Complete conversation logs with prompts & responses
Cost breakdown by model, user, and time period
Performance metrics like response time and token usage
Error tracking with full stack traces
User analytics showing engagement patterns

🎮 Real example from my Wei AI agent:

User: "Help me build a morning routine"
→ Function call: getUserHabits()
→ Function call: searchMemories("morning routine")
→ Function call: addMemory() to store preferences

Every step logged with costs, timing, and success rates! 📈

🚀 Production benefits I'm seeing:

⚡ Identify slow function calls instantly
💰 Track exact costs per user/conversation
🎯 Optimize prompts based on success rates
🛡️ Debug errors with complete context
📱 Monitor usage patterns and scaling needs
🌍 Compare model performance across regions

🛠️ The complete integration took maybe 1 hour:

✅ 10 min: Update OpenAI client baseURL
✅ 20 min: Keywords AI service setup
✅ 20 min: Custom event tracking
✅ 10 min: Health monitoring

Most time was on custom analytics, core logging is instant! ⭐

🎯 Key takeaways:

Observability is essential for production AI agents
Keywords AI makes LLM monitoring effortless
User tracking enables powerful analytics
Custom events provide business insights
Essential for any serious AI application

Start monitoring your agents today! 🚀

Technical Implementation Deep Dive

Complete Keywords AI Service Implementation

interface KeywordsAIConfig {
  apiKey: string;
  baseURL: string;
}

interface KeywordsAILogData {
  customer_identifier?: string;
  thread_id?: string;
  customer_user_id?: string;
  model: string;
  messages: Array<{
    role: string;
    content: string;
    timestamp?: string;
  }>;
  response?: string;
  tokens_used?: number;
  response_time?: number;
  cost?: number;
  metadata?: Record<string, any>;
}

export class KeywordsAIService {
  private config: KeywordsAIConfig;

  constructor() {
    this.config = {
      apiKey: process.env.KEYWORDS_AI_API_KEY || '',
      baseURL: 'https://api.keywordsai.co/api',
    };
  }

  /**
   * Get enhanced completion parameters for Keywords AI
   */
  getCompletionParams(
    userId?: string | null,
    conversationId?: string,
    metadata?: Record<string, any>
  ) {
    return {
      customer_identifier: userId || 'anonymous_user',
      thread_id: conversationId || `conversation_${Date.now()}`,
      customer_user_id: userId,
      ...metadata,
    };
  }

  /**
   * Log conversation data to Keywords AI for analytics
   */
  async logConversation(data: KeywordsAILogData): Promise<void> {
    if (!this.config.apiKey) {
      console.warn('Keywords AI not configured, skipping logging');
      return;
    }

    try {
      await fetch(`${this.config.baseURL}/logs`, {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${this.config.apiKey}`,
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({
          ...data,
          timestamp: new Date().toISOString(),
          source: 'wei-ai-assistant',
        }),
      });
    } catch (error) {
      console.error('Failed to log conversation to Keywords AI:', error);
    }
  }

  /**
   * Track specific events for analysis
   */
  async trackEvent(
    event: string,
    userId?: string,
    properties?: Record<string, any>
  ): Promise<void> {
    if (!this.config.apiKey) return;

    try {
      await fetch(`${this.config.baseURL}/events`, {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${this.config.apiKey}`,
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({
          event,
          user_id: userId,
          properties: {
            ...properties,
            timestamp: new Date().toISOString(),
            source: 'wei-ai-assistant',
          },
        }),
      });
    } catch (error) {
      console.error('Failed to track event:', error);
    }
  }

  /**
   * Get user analytics and usage metrics
   */
  async getUserMetrics(userId: string): Promise<KeywordsAIMetrics | null> {
    if (!this.config.apiKey) return null;

    try {
      const response = await fetch(
        `${this.config.baseURL}/analytics/users/${userId}/metrics`,
        {
          headers: {
            'Authorization': `Bearer ${this.config.apiKey}`,
          },
        }
      );

      if (!response.ok) {
        throw new Error(`Failed to fetch user metrics: ${response.statusText}`);
      }

      return await response.json();
    } catch (error) {
      console.error('Failed to fetch user metrics:', error);
      return null;
    }
  }
}

OpenAI Client Integration

import OpenAI from "openai";
import { keywordsAIService } from "@/lib/keywords-ai";

// Initialize OpenAI client with Keywords AI proxy
const openai = new OpenAI({
  baseURL: "https://api.keywordsai.co/api",
  apiKey: process.env.KEYWORDS_AI_API_KEY || process.env.OPENAI_API_KEY,
});

export async function POST(req: Request) {
  try {
    const { model, messages, functions, userCache } = await req.json();

    // Get user ID for tracking
    const userId = await getCurrentUserId();

    // Get Keywords AI parameters for enhanced logging
    const keywordsAIParams = keywordsAIService.getCompletionParams(
      userId,
      userCache?.conversationId,
      { source: 'wei-ai-assistant' }
    );

    // Make the API call with enhanced logging
    const completion = await openai.chat.completions.create({
      model,
      messages,
      functions,
      ...keywordsAIParams,  // This enables automatic logging
    });

    return NextResponse.json(completion);
  } catch (error) {
    console.error("Error in /chat/completions:", error);
    return NextResponse.json({ error: error.message }, { status: 500 });
  }
}

Advanced Event Tracking

// Track habit completion events
await keywordsAIService.trackHabitCompletion(
  userId,
  habitId,
  habitName,
  pointsEarned
);

// Track memory operations
await keywordsAIService.trackMemoryOperation(
  userId,
  'search',
  { query: 'user preferences', results_count: 5 }
);

// Track search operations
await keywordsAIService.trackSearchOperation(
  userId,
  'web',
  query,
  searchResponse.results.length
);

// Track agent interactions
await keywordsAIService.trackAgentInteraction(
  userId,
  'habit-coach',
  'function_call',
  { function_name: 'getUserHabits', success: true }
);

Function Call Tracking Integration

// Enhanced function call handling with tracking
async function handleDatabaseFunction(name: string, args: any, userCache: any) {
  const userId = await getCurrentUserId();

  switch (name) {
    case "searchMemories":
      try {
        const memories = await memoryService.searchMemories(
          args.query, userId, args.limit || 5
        );

        // Track the memory operation
        if (userId) {
          await keywordsAIService.trackMemoryOperation(
            userId,
            'search',
            { 
              query: args.query,
              results_count: memories.length,
              limit: args.limit 
            }
          );
        }

        return JSON.stringify({ memories, count: memories.length });
      } catch (error) {
        // Track the error
        if (userId) {
          await keywordsAIService.trackEvent('memory_error', userId, {
            operation: 'search',
            error: error.message
          });
        }
        throw error;
      }

    case "searchWeb":
      try {
        const searchResponse = await tavilyService.search({
          query: args.query,
          topic: args.topic || 'general',
          max_results: args.max_results || 5,
        });

        // Track search operation
        if (userId) {
          await keywordsAIService.trackSearchOperation(
            userId,
            'web',
            args.query,
            searchResponse.results.length
          );
        }

        return JSON.stringify({
          success: true,
          ...searchResponse
        });
      } catch (error) {
        // Track search errors
        if (userId) {
          await keywordsAIService.trackEvent('search_error', userId, {
            search_type: 'web',
            query: args.query,
            error: error.message
          });
        }
        throw error;
      }
  }
}

Production Benefits & Use Cases

1. Cost Optimization

// Get cost breakdown by user
const userMetrics = await keywordsAIService.getUserMetrics(userId);
console.log(`User ${userId} has spent $${userMetrics.total_cost} this month`);

// Track high-cost operations
await keywordsAIService.trackEvent('high_cost_operation', userId, {
  operation: 'complex_search',
  estimated_cost: 0.15,
  tokens_used: 2500
});

2. Performance Monitoring

// Monitor response times
const startTime = Date.now();
const completion = await openai.chat.completions.create(options);
const responseTime = Date.now() - startTime;

await keywordsAIService.trackEvent('performance_metric', userId, {
  operation: 'chat_completion',
  response_time: responseTime,
  model: options.model,
  tokens: completion.usage?.total_tokens
});

3. Error Tracking & Debugging

try {
  await processAgentRequest(request);
} catch (error) {
  await keywordsAIService.trackEvent('agent_error', userId, {
    error_type: error.constructor.name,
    error_message: error.message,
    request_context: request.context,
    stack_trace: error.stack?.slice(0, 1000) // Truncate for storage
  });
  throw error;
}

4. User Behavior Analytics

// Track user engagement patterns
await keywordsAIService.trackEvent('user_session', userId, {
  session_duration: sessionDuration,
  messages_sent: messageCount,
  functions_called: functionCallCount,
  agent_types_used: ['habit-coach', 'general-assistant']
});

Dashboard Features from Keywords AI

LLM Logs

Complete request/response history
Prompt and completion visibility
Token usage tracking
Response time metrics
Cost calculation per request

Advanced Filtering

Filter by user, model, status, time range
Search through prompts and responses
Custom metadata filtering
Error-specific filtering

Full-Text Search

Search across all logged conversations
Find specific prompts or responses
Debug issues quickly
Analyze usage patterns

Analytics Dashboard

User engagement metrics
Cost trends over time
Model performance comparison
Error rate monitoring
Custom event analytics

Give a star: https://github.com/Anora-Labs/eliza-agent-orchestration.

my linkedin in case: https://www.linkedin.com/in/abdibrokhim/.

This Article demonstrates a production-ready Mem0+Supabase integration in an AI agent system. The code examples are from the actual Wei AI Agent project, showing real-world implementation patterns.

Give Your AI Agents Persistent Memory with Mem0

Ibrohim Abdivokhidov — Wed, 25 Jun 2025 08:58:51 +0000

🚀 Want your AI agents to remember past conversations and learn from user interactions? Here's how I integrated @mem0ai into my AI agent system to give them persistent, intelligent memory.

The result? Agents that truly understand context and personalize experiences! 🧵👇

🤔 The Problem: Most AI agents start fresh every conversation. They can't remember user preferences, past decisions, or successful strategies.

Solution: Mem0's AI-powered memory layer = Agents that learn, adapt, and provide personalized experiences across sessions! 🧠⚡

📊 Why Mem0? According to their research paper:
• 26% higher accuracy than OpenAI Memory
• 91% lower latency
• 90% token savings

Plus full TypeScript support and enterprise-grade features! 📈

🛠️ Setup is surprisingly simple. First, install the package:

npm install mem0ai
# or for Python
pip install mem0ai

Get your API key from Mem0 Platform and you're ready to go! 🎯

💡 The magic starts with configuration. Here's my production setup using Supabase + OpenAI:

const memoryConfig = {
  embedder: {
    provider: 'openai',
    config: {
      model: 'text-embedding-3-small',
    }
  },
  historyStore: {
    provider: 'supabase',
    config: {
      tableName: 'memory_history'
    }
  }
}

🔧 Creating the MemoryService class for seamless integration:

export class MemoryService {
  private memory: Memory;

  async addMemories(messages, userId, metadata) {
    return await this.memory.add(messages, {
      userId,
      metadata: { timestamp: new Date().toISOString(), ...metadata }
    });
  }
}

Clean, modular, production-ready! ✨

🎯 Function calling integration makes memory operations automatic:

{
  name: "addMemory",
  description: "Store conversation memories",
  parameters: {
    type: "object",
    properties: {
      messages: { type: "array" },
      metadata: { type: "object" }
    }
  }
}

The AI decides when to save memories naturally! 🤖

📈 The AI agent conversation flow with memory:

User: "I'm vegetarian and allergic to nuts"
AI calls addMemory() to store preferences
Next session: User asks "What should I eat?"
AI calls searchMemories("food preferences")
Gets personalized recommendations!

Context persistence = magic! ✨

🔍 Memory search is incredibly powerful:

// Search relevant memories
await memoryService.searchMemories(query, userId, limit)

// Get contextual memories
await memoryService.getRelevantMemories(
  currentMessage, 
  userId, 
  conversationHistory
)

Semantic search finds exactly what's needed! 🎯

⚡ Real-world memory operations I implemented:

case "searchMemories":
  const memories = await memoryService.searchMemories(
    args.query, userId, args.limit || 5
  );
  return JSON.stringify({ memories, count: memories.length });

case "addMemory":
  await memoryService.addMemories(
    args.messages, userId, args.metadata
  );
  return JSON.stringify({ success: true });

🎮 Advanced features that make the difference:

User & Agent Memory: Separate memory spaces for users and AI agents
Session Memory: Short-term context for conversations
Metadata Filtering: Precise memory retrieval with structured data
Memory History: Track how memories evolve over time
Batch Operations: Update/delete multiple memories efficiently

🛡️ Error handling for production reliability:

try {
  const result = await memoryService.addMemories(messages, userId);
  return { success: true, memoryId: result };
} catch (error) {
  console.error('Memory operation failed:', error);
  return { error: "Failed to add memory", success: false };
}

Always graceful degradation! 🛡️

📊 Real example from my Wei AI agent:

User: "I want to build a morning routine"
Agent: Stores preference + suggests habits
User (next week): "How's my routine going?"
Agent: Retrieves memory + provides personalized progress report with specific habits mentioned before

Continuity = engagement! 🎯

🚀 Performance benefits I'm seeing:

⚡ Sub-100ms memory operations
🧠 Intelligent memory consolidation
💰 90% reduction in context tokens
🎯 Highly relevant memory retrieval
📱 Works seamlessly with streaming
🌍 Scales with user growth

🛠️ The complete integration took about 3 hours:

✅ 45 min: Mem0 service setup
✅ 60 min: Function calling integration
✅ 45 min: Error handling & testing
✅ 30 min: Production optimizations

Most time was on polish, not core functionality! ⭐

🎯 Key takeaways:

Memory transforms AI agents from tools to companions
Mem0's API is developer-friendly and performant
Function calling makes memory operations seamless
Context persistence dramatically improves UX
Essential for any serious AI application

Try building with memory! 🚀

Technical Implementation Deep Dive

Complete Memory Service Implementation

import { Memory } from 'mem0ai/oss';

const memoryConfig = {
  version: 'v1.1',
  embedder: {
    provider: 'openai',
    config: {
      apiKey: process.env.OPENAI_API_KEY,
      model: 'text-embedding-3-small',
    },
  },
  vectorStore: {
    provider: 'memory',
    config: {
      collectionName: 'memories',
      dimension: 1536,
    },
  },
  llm: {
    provider: 'openai',
    config: {
      apiKey: process.env.OPENAI_API_KEY,
      model: 'gpt-4o-mini',
      temperature: 0.2,
      maxTokens: 1500,
    },
  },
  historyStore: {
    provider: 'supabase',
    config: {
      supabaseUrl: process.env.NEXT_PUBLIC_SUPABASE_URL,
      supabaseKey: process.env.SUPABASE_SERVICE_ROLE,
      tableName: 'memory_history',
    },
  },
};

export class MemoryService {
  private memory: Memory;

  constructor() {
    this.memory = new Memory(memoryConfig);
  }

  async addMemories(messages, userId, metadata) {
    try {
      const result = await this.memory.add(messages, {
        userId,
        metadata: {
          timestamp: new Date().toISOString(),
          ...metadata,
        },
      });
      return result;
    } catch (error) {
      console.error('Error adding memories:', error);
      throw error;
    }
  }

  async searchMemories(query, userId, limit = 5) {
    try {
      const result = await this.memory.search(query, { userId, limit });
      return result;
    } catch (error) {
      console.error('Error searching memories:', error);
      throw error;
    }
  }

  async getRelevantMemories(currentMessage, userId, conversationHistory = [], limit = 3) {
    try {
      // Search for memories related to current message
      const relevantMemories = await this.searchMemories(currentMessage, userId, limit);

      // Also search based on conversation context
      if (conversationHistory.length > 0) {
        const recentMessages = conversationHistory.slice(-3);
        const contextQuery = recentMessages.map(msg => msg.content).join(' ');
        const contextMemories = await this.searchMemories(contextQuery, userId, limit);

        // Combine and deduplicate
        const allMemories = [...relevantMemories.results, ...contextMemories.results];
        const uniqueMemories = allMemories.filter(
          (memory, index, self) => index === self.findIndex(m => m.id === memory.id)
        );

        return uniqueMemories.slice(0, limit);
      }

      return relevantMemories.results;
    } catch (error) {
      console.error('Error getting relevant memories:', error);
      return [];
    }
  }
}

API Route Integration

// Memory function definitions for AI agents
const memoryFunctions = [
  {
    name: "searchMemories",
    description: "\"Search through user memories for relevant information\","
    parameters: {
      type: "object",
      properties: {
        query: { type: "string", description: "\"Search query\" },"
        limit: { type: "number", description: "\"Max results (default: 5)\" }"
      },
      required: ["query"]
    }
  },
  {
    name: "addMemory",
    description: "\"Store new memories from conversation\","
    parameters: {
      type: "object",
      properties: {
        messages: {
          type: "array",
          items: {
            type: "object",
            properties: {
              role: { type: "string" },
              content: { type: "string" }
            }
          }
        },
        metadata: { type: "object" }
      },
      required: ["messages"]
    }
  },
  {
    name: "getRelevantMemories",
    description: "\"Get contextually relevant memories\","
    parameters: {
      type: "object",
      properties: {
        currentMessage: { type: "string" },
        conversationHistory: { type: "array" },
        limit: { type: "number" }
      },
      required: ["currentMessage"]
    }
  }
];

// Function call handler
async function handleMemoryFunction(name, args, userId) {
  switch (name) {
    case "searchMemories":
      try {
        const memories = await memoryService.searchMemories(
          args.query, userId, args.limit || 5
        );
        return JSON.stringify({
          memories,
          count: Array.isArray(memories) ? memories.length : 0
        });
      } catch (error) {
        return JSON.stringify({
          error: "Failed to search memories",
          memories: []
        });
      }

    case "addMemory":
      try {
        const result = await memoryService.addMemories(
          args.messages, userId, args.metadata
        );
        return JSON.stringify({
          success: true,
          message: "Memory added successfully",
          memoryId: result
        });
      } catch (error) {
        return JSON.stringify({
          error: "Failed to add memory",
          success: false
        });
      }

    case "getRelevantMemories":
      try {
        const relevantMemories = await memoryService.getRelevantMemories(
          args.currentMessage,
          userId,
          args.conversationHistory || [],
          args.limit || 3
        );
        return JSON.stringify({
          memories: relevantMemories,
          count: Array.isArray(relevantMemories) ? relevantMemories.length : 0
        });
      } catch (error) {
        return JSON.stringify({
          error: "Failed to get relevant memories",
          memories: []
        });
      }
  }
}

Supabase Database Schema

-- Memory history table for Mem0
CREATE TABLE memory_history (
  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
  user_id UUID REFERENCES auth.users(id),
  memory_id TEXT NOT NULL,
  operation TEXT NOT NULL,
  data JSONB,
  created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
  updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
);

-- Enable RLS
ALTER TABLE memory_history ENABLE ROW LEVEL SECURITY;

-- RLS Policies
CREATE POLICY "Users can view own memory history" ON memory_history
  FOR SELECT USING (auth.uid() = user_id);

CREATE POLICY "Users can insert own memory history" ON memory_history
  FOR INSERT WITH CHECK (auth.uid() = user_id);

-- Indexes for performance
CREATE INDEX memory_history_user_id_idx ON memory_history(user_id);
CREATE INDEX memory_history_memory_id_idx ON memory_history(memory_id);
CREATE INDEX memory_history_created_at_idx ON memory_history(created_at);

Production Use Cases

1. Personal AI Assistant

// Store user preferences
messages = [
  { role: "user", content: "I prefer morning workouts and vegetarian meals" }
];
await memoryService.addMemories(messages, userId, { category: "preferences" });

// Later retrieval
const preferences = await memoryService.searchMemories("user preferences", userId);

2. Learning Agent

// Track user progress
messages = [
  { role: "user", content: "I completed the JavaScript basics course" },
  { role: "assistant", content: "Great! Ready for React next?" }
];
await memoryService.addMemories(messages, userId, { category: "learning" });

3. Customer Support Agent

// Remember past issues
const relevantIssues = await memoryService.searchMemories(
  "billing problems", userId, 3
);
// Provide context-aware support

Performance Optimizations

Memory Consolidation

Automatically merge similar memories
Remove outdated information
Maintain memory relevance scores

Caching Strategy

// Cache frequently accessed memories
const memoryCache = new Map();

async function getCachedMemories(userId, query) {
  const cacheKey = `${userId}:${query}`;
  if (memoryCache.has(cacheKey)) {
    return memoryCache.get(cacheKey);
  }

  const memories = await memoryService.searchMemories(query, userId);
  memoryCache.set(cacheKey, memories);
  return memories;
}

Batch Operations

// Batch update memories for efficiency
const updates = [
  { memory_id: "123", text: "Updated preference" },
  { memory_id: "456", text: "New information" }
];
await memoryService.batchUpdate(updates);

This Article demonstrates a production-ready Mem0 integration in an AI agent system. The code examples are from the actual Wei AI Agent project, showing real-world implementation patterns.

How to Give Your AI Agents Real-Time Search Superpowers with Tavily

Ibrohim Abdivokhidov — Tue, 24 Jun 2025 14:19:00 +0000

This article demonstrates a real-world implementation of Tavily search integration in an AI agent system. The code examples are taken from actual production code in the open-source Wei AI Agent project.

cover image. made by https://www.linkedin.com/in/abdibrokhim/
Integrating @tavilyai with Function Calling in AI Agentic Apps 🧵

Taking a closer look at this open-source project: https://github.com/Anora-Labs/eliza-agent-orchestration.

official website: https://www.tavily.com/
🚀 Building AI agents that can search the web in real-time? Here’s how I integrated @TavilyAI with function calling to give my AI agents instant access to current information.

The result? Agents that can answer questions about today’s news, current events, and live data! 🧵👇

official website: https://www.tavily.com/
🤔 The Problem: Most AI models are trained on data with a cutoff date. They can’t tell you about breaking news, current stock prices, or what happened yesterday.

Solution: Function calling + Tavily’s real-time search API = AI agents with up-to-the-minute knowledge! ⚡

official website: https://www.tavily.com/
🛠️ Setting up Tavily is surprisingly simple. First, install and configure:

npm i @tavily/core

Add your Tavily API key to .env

TAVILY_API_KEY=your_key_here_goes_here
That’s it for dependencies! No complex SDKs or heavy libraries needed. 📦

💡 The magic happens with function definitions. Here’s how I defined Tavily search functions for my AI agents:

{
name: "searchWeb",
description: "Search the internet for real-time information",
parameters: {
type: "object",
properties: {
query: { type: "string" },
topic: { enum: ["general", "news"] },
max_results: { type: "number" }
}
}
}
🔧 The Tavily service class is clean and modular:

export class TavilyService {
async search(options: TavilySearchOptions) {
const response = await fetch('https://api.tavily.com/search', {
method: 'POST',
headers: {
'Authorization': Bearer ${this.apiKey},
'Content-Type': 'application/json'
},
body: JSON.stringify(searchPayload)
});
return response.json();
}
}
🎯 Function calling integration is where it gets interesting. When the AI decides it needs current information, it automatically calls the search function:

case "searchWeb":
const searchResponse = await tavilyService.search({
query: args.query,
topic: args.topic || 'general',
max_results: args.max_results || 5
});
return JSON.stringify(searchResponse);
📈 The AI agent conversation flow:

User asks: “What’s happening with Bitcoin today?”
AI recognizes it needs current data
AI calls searchWeb(“Bitcoin price news today”)
Tavily returns real-time results
AI synthesizes the information into a natural response

All automatic! 🤯

🗞️ Specialized functions for different use cases:

// General web search
await tavilyService.searchGeneral(query, maxResults)

// Current news
await tavilyService.searchNews(query, maxResults, 'day')

// Quick answers
await tavilyService.getQuickAnswer(query)
Each optimized for different types of information retrieval! 📊

⚡ Pro tip: Format the results for better AI consumption:

formatSearchResults(searchResponse: TavilySearchResponse): string {
let formatted = Search Query: "${query}"\n\n;
if (answer) formatted += Answer: ${answer}\n\n;

results.forEach((result, index) => {
formatted += ${index + 1}. ${result.title}\n;
formatted += Content: ${result.content}\n\n;
});

return formatted;
}
🎛️ Error handling is crucial for production:

try {
const searchResponse = await tavilyService.search(options);
return JSON.stringify({ success: true, ...searchResponse });
} catch (error) {
return JSON.stringify({
error: "Failed to search the web",
message: error.message
});
}
Always graceful degradation! 🛡️

📊 Real-world example from my Wei AI agent:

User: “What are the latest developments in AI safety?”

AI Agent:

Calls searchNews(“AI safety developments”, 5, “week”)
Gets 5 recent articles from Tavily
Synthesizes findings into comprehensive answer
Cites sources with URLs

try Wei at https://wei.yaps.gg
🎮 Advanced features I’m using:

Domain filtering: Include/exclude specific sites
Time range controls: Last day, week, month
Content depth: Basic vs advanced search
Answer extraction: Get direct answers, not just links
Multiple topics: General web vs news-specific

official website: https://www.tavily.com/
🚀 Performance benefits:

⚡ Sub-second response times
🎯 Highly relevant results (scored by relevance)
📱 Works great with streaming responses
💰 Cost-effective vs other search APIs
🌍 Global coverage with localization

official website: https://www.tavily.com/
🎯 Key takeaways:

Function calling makes AI agents incredibly extensible
Tavily’s API is developer-friendly and fast
Real-time search transforms user experience
Simple integration, powerful results
Essential for any serious AI application

Try it yourself! 🚀

Technical Implementation Details
Complete Function Definition:

const searchFunctions = [
{
name: "searchWeb",
description: "Search the internet for real-time information and current events",
parameters: {
type: "object",
properties: {
query: {
type: "string",
description: "The search query to find information on the web"
},
topic: {
type: "string",
enum: ["general", "news"],
description: "The type of search - 'general' for broad searches, 'news' for current events"
},
max_results: {
type: "number",
description: "Maximum number of search results to return (1-20, default: 5)"
},
time_range: {
type: "string",
enum: ["day", "week", "month", "year"],
description: "Time range for news searches"
},
include_answer: {
type: "boolean",
description: "Whether to include an AI-generated answer summary"
}
},
required: ["query"]
}
}
];
Error Handling Best Practices:

async function handleSearchFunction(args: any) {
try {
// Validate inputs
if (!args.query || typeof args.query !== 'string') {
throw new Error('Query parameter is required and must be a string');
}

// Call Tavily with validated parameters
const searchResponse = await tavilyService.search({
  query: args.query,
  topic: args.topic || 'general',
  max_results: Math.min(Math.max(args.max_results || 5, 1), 20),
  time_range: args.time_range,
  include_answer: args.include_answer !== false,
});

// Track usage for analytics
await trackSearchOperation(userId, 'web', args.query, searchResponse.results.length);

return {
  success: true,
  ...searchResponse,
  formatted_results: tavilyService.formatSearchResults(searchResponse)
};

} catch (error) {
console.error('Search function error:', error);
return {
error: "Failed to search the web",
success: false,
message: error instanceof Error ? error.message : "Unknown search error"
};
}
}
Usage Analytics Integration:

// Track search operations for insights
await keywordsAIService.trackSearchOperation(
userId,
'web', // search type
args.query,
searchResponse.results.length
);
Give a star: https://github.com/Anora-Labs/eliza-agent-orchestration.

my linkedin in case: https://www.linkedin.com/in/abdibrokhim/

Show HN: INDIANS just took my last hope and it HURTS!

Ibrohim Abdivokhidov — Wed, 18 Jun 2025 13:06:02 +0000

Yo, sap?!

My name is Ibrohim Abdivokhidov (aka abdibrokhim). Just 21 years old guy from Uzbekistan, Central Asia, FUCKING beautiful country you’ve never seen before.

Just graduated from one of the greatest Universities (e.g., New Uzbekistan University, aka Presidential University). Bachelor’s in Computer Science, specifically Software Engineering.

My grades are just fine (not bad and not good enough), 3.15/4.50 CGPA.

I know it’s too low.

I’m just curious about everything. And sometimes it’s hard to keep up with everything in a HIGH level.

I just love hackathons, competitions, and challenges.

Most of the time, or even all the time (beside academic things, and studies at University), I built stuff, create things, design, and have fun. (source)

Moreover, I like trying out every opportunity whether it’s related to my field or not. Fuck it, “just try it out”.

Since, December 2023; I’ve participated in over 70+ hackathons including worldwide competitions, and challenges. I’ve completed 400+ applications, including job positions, fellowship, internship, different programs, and many others. And failed almost in all of them.

IT HURTS!

And now, I started to hate Hackathons. Especially where INDIANS are the Judges.

Hackathons was my almost my last even more than a hobby. And now even I lost them. Thanks, INDIANS!! Appreciate it!

I almost have no motivation to participate further. idk. but there is always from my inside saying: “you can make it”, “just try it out on more time”. FUCK this is killin’ me literally.

Half me saying go ahead, when half me saying fuck those unfair INDIANS judges. they are fuckin’ blind.

I can’t describe my feelings. You can’t even feel them.

Broo, just. it’s crazy. Imagine you did great stuff. LITERALLY something cool to use as a normal human. And boom you got 2nd or 3rd place , or even failed to get top5. Because some JUDGES are too *good to be A JUDGE.

IT HURTS again!

Let’s take as an example my last 3 hackathons.

Recently, there been organized “X-RAPTORS HACKATHON”.

LISTEN, I got 2nd place.

it is crazy…

I’m disagree with judges opinion or whatever shit they made, TOTALLY and LITERALLY. They just graded projects UNFAIR and BLIND.

This BUGGY and BROKEN project got 1st place. Here’s a website: https://idea-forge-x.vercel.app/.

UI of https://idea-forge-x.vercel.app/
and Github repo: https://github.com/ManvendraSinghTanwar/IdeaForge-X. and their short demo video: https://www.youtube.com/watch?v=DxKM6Q_vEuE.

Please, take a moment and check all the project links (above). I’m not kidding at all.

Well, I hope you’ve seen that landing page is BROKEN. Most of the functionality of the app are not working properly and just static. Social accounts connection is just a trashed feature. I’m even not sure whether *they built it or just copyshited from v0.dev community templates. Just open their website and open browser tools. inside

tag you can see the following: .

UI of https://idea-forge-x.vercel.app/ + chrome devtools.
It could be VIBE CODED. Well, it’s totally FINE. But it could be just COPYSHITED as well as I said earlier. And here’s my brutal words. ARE JUDGES BLIND? or JUDGES playing INDIAN-FOR-INDIAN game.

So sorry for being rude or using shitty words. but you made me to hate hackathons.

IT HURTS again!

Well, here’s my project’s Github link: https://github.com/abdibrokhim/figma-ai. and Quick demo video: https://drive.google.com/file/d/1qTfebZyUKBzM-2rnPeEFAKatDh6XAxRE/view?usp=drive_link.

tbh, It was vibe coded 50/50 just to speed up with time.

UI of Flow AI

UI of Flow AI
Fuck IT.

Possibilities are endless with FlowAI. It supports HUGE workflows pretty nuts. BEST for Design Agencies or Soloprenuers with tens of clients.

Even NORMAL user can clearly see that, the thing (FlowAI) I built a way more BETTER, FUNCTIONAL, and DESERVE 1st place rather than some shitty non-functional project like IdeaForge-X !!!

Judge? — I just HATE you! sorrrry,

IT just HURTS me so much!

Even ORGANIZERS knows that, I built cool stuff as always. Their comments was following when i told them that JUDGES mis-graded submitted projects — “saying with 110% appreciation and 140% love to your project”.

No way. Why not then to ask them to grade properly? or they are just JUDING (blindly) to get SIGNED LETTER (aka VISA purposes).

Another one, “LIFE QUEST BALANCE HACKATHON”.

I got 3rd place.

1st place winner: Team Zen — Zenventures.

UI of Zenventures
2nd place: ForCoders — “Rewardify”.

UI of Rewardify
I don’t have any project or Github links. Because they are not valid anymore. WEIRD, isn’t it?.

and finally 3rd place. my projects Wei — “🌱 Wei: The AI Agents For Personal Growth”. Here’s the Github repo: https://github.com/abdibrokhim/wei | and project Demo (e.g., presentation slides): https://www.canva.com/design/DAGlvqFuJtI/dX_Yyydp7dMhGQBlcKXr4g/view?utm_content=DAGlvqFuJtI&utm_campaign=designshare&utm_medium=link2&utm_source=uniquelinks&utlId=h46d5cf4613.

Wei: The AI Agents For Personal Growth

Wei: Architecture
Wei: It’s AI Voice Agentic app with realtime streaming OpenAI API.

Wait, whattafk!

How it can loose for Rewardify. That just a …,idk how to decribe , just a generic project. Compare to Wei that was built from scratch and it’s Agentic App, now way. noooo.

IT HURTS!

And last but not least. “Blazingly Fast Hackathon”.

I got 3rd place again.

This is the project that got 1st place. Demo video: https://www.youtube.com/watch?v=-KUp34PHJuc.

UI of project 1
2nd place winner Github repo: https://github.com/Sidharth-Singh10/CargoCut.

UI of project 2
Wait what. isn’t it look like as one project with different designs.

when i did a brief observations, i found that both study at the same university.

well, okey. than i can simply submit 3 projects with a bit different UI and colors and get the top 3 places? fuck. why?

Huh!

Here’s my project: https://youtu.be/ahZV6aAdnVI?si=SCWhnljRfOCIevav.

UI of notlink
Totally different UI, clean colors, simple to use and way more better and secure.

Nooo, bruh. Every time when i saw notlink. It reminds me BAD memories. VERY Bad memories.

Hey, JUDGE!! How this is even possible??

Let’s assume you’re a JUDGE. You should just normally grade those three projects. NO BIAS!!

After watching all three demos or going thro the Github repos. It’s Fucking obvious that my project (notlink) way more better in all sides; documentation, demo video, code clarity, whatever… .

FUCK it!

I don’t believe my (notlink’s) UI/UX is worse than those two trashed stuff.

Because UI/UX grading was less. Unbelieveable, lmao! Seems JUDGES never seen or heard what is Shadcn/UI, TailwindCSS or NextJS. Sorry , but you’re not qualified to grade the hackathon, projects, or whatever that may FUCK UP some ones BIG dreams.

NAH!,

Indians playing their game again and again. Trash. I can’t say anything. Just trashed UI/UX. Even they’ve not deployed their trash URL shorteners. WTF? why cash then? Maybe developer further ? FUCK!

When, notlink has 93 stars, 15 forks within a month roughly, no-ads, $0 spent for marketing, pure traffic from my comprehensive tutorials.

Sorry, but I just HATE you.

I (my projects) should not loose or get 2nd, 3rd places because some judges can’t or don’t know how to ackshually JUDGE the submitted projects properly and FAIRLY.

I got this message: “I assume they are Indians and know how to help each other”.

then I replied them: “I assume they are (JUDGES) Indians and know how to help each other”.

i am on X, btw: x.com/abdibrokhim.

ANORA's largest update yet

Ibrohim Abdivokhidov — Mon, 26 May 2025 10:16:39 +0000

cool, here we go…

hello I just released a new version of ANORA.

i think it’s a big step forward in my mission to build the best place to create with AI.

i’m super excited to show you!!

Introducing ANORA 0.2.8 release:

Almost Blank But Intelligent Canvas.
Over 50+ AI models are free to use, even for free users.
Over 50+ pre-made image sizes for social media posting.
Over 10+ image styles to choose from.
Over 15+ flow templates for getting started.
Download images, videos, and plain text for free.
Knows your Canvas: Spotlight Search among 10+ flows.
Customize Canvas as you wish and love it to be.
Virtual cursor for better visual user experience.
WebCam: take photos and edit them on the go.
Infinitely generate/edit text, images, and videos in natural language
AI auto-suggestions all around your Canvas.
Tab, tab, tab.
Upload and store your own assets. (Pro)
Copy/paste and duplicate are made easy.
Show/hide UI for more focused work.
Center a flow or individual block to take sss.
Export flows as an image.
Connect from/to blocks from anywhere.
Track status of running flows with ease.
Weekly coupon codes to redeem xyz credits.
Pay-as-you-go: add credits to use better AI models.
All listed (next listing) features are absolutely free to use.
10K credits cost as little as $9: approx. 20 HQ videos, 400 HQ images, 12K text generations.
Super simple, (but) F*ckin’ cool, (FLORA/Figma-like) UI/UX.
Powered by AI/ML API.

ANORA — Intelligent canvas for infinite creativity.

try anora.yaps.gg/projects ( 500 free credits + 100 using code: 1E9DF )

watch on youtube: https://youtu.be/N8bXoMinG1k

Show HN: I built Hedra, Flora, Flowith, Google Flow alternative, but better.

Ibrohim Abdivokhidov — Thu, 22 May 2025 12:18:13 +0000

(interesting, other screenshots listed below. must see them!!)

Finally i did something that i really enjoy doing. I built ANORA — Intelligent canvas for infinite creativity. The idea is super simple. Just to give platform where creative people can do creative stuff in creatively designed UI/UX platform such as ANORA. try now and get 500 Free credits that are rolled over every month. and also use this code (74EED) to get additional 100 free credits.

“designed, built, and shipped by me solo”. github.com/abdibrokhim or x.com/abdibrokhim. for investors, book a call: https://cal.com/abdibrokhim.

More photos:

Make flows in… (f*cking COOOL Ui/uX):

https://x.com/abdibrokhim/status/1925519448045154676