DEV Community: Sathnindu Kottage

ChatsAPI — The World’s Fastest AI Agent Framework

Sathnindu Kottage — Sun, 08 Dec 2024 12:54:29 +0000

GitHub: https://github.com/chatsapi/ChatsAPI
Library: https://pypi.org/project/chatsapi/

Artificial Intelligence has transformed industries, but deploying it effectively remains a daunting challenge. Complex frameworks, slow response times, and steep learning curves create barriers for businesses and developers alike. Enter ChatsAPI — a groundbreaking, high-performance AI agent framework designed to deliver unmatched speed, flexibility, and simplicity.

In this article, we’ll uncover what makes ChatsAPI unique, why it’s a game-changer, and how it empowers developers to build intelligent systems with unparalleled ease and efficiency.

What Makes ChatsAPI Unique?

ChatsAPI is not just another AI framework; it’s a revolution in AI-driven interactions. Here’s why:

Unmatched Performance ChatsAPI leverages SBERT embeddings, HNSWlib, and BM25 Hybrid Search to deliver the fastest query-matching system ever built.

Speed: With sub-millisecond response times, ChatsAPI is the world’s fastest AI agent framework. Its HNSWlib-powered search ensures lightning-fast retrieval of routes and knowledge, even with large datasets.

Efficiency: The hybrid approach of SBERT and BM25 combines semantic understanding with traditional ranking systems, ensuring both speed and accuracy.

Seamless Integration with LLMs
ChatsAPI supports state-of-the-art Large Language Models (LLMs) like OpenAI, Gemini, LlamaAPI, and Ollama. It simplifies the complexity of integrating LLMs into your applications, allowing you to focus on building better experiences.
Dynamic Route Matching
ChatsAPI uses natural language understanding (NLU) to dynamically match user queries to predefined routes with unparalleled precision.

Use parameter extraction with @extract to simplify input handling, no matter how complex your use case.

Simplicity in Design We believe that power and simplicity can coexist. With ChatsAPI, developers can build robust AI-driven systems in minutes. No more wrestling with complicated setups or configurations.

The Advantages of ChatsAPI

High-Performance Query Handling
Traditional AI systems struggle with either speed or accuracy — ChatsAPI delivers both. Whether it’s finding the best match in a vast knowledge base or handling high volumes of queries, ChatsAPI excels.

Flexible Framework
ChatsAPI adapts to any use case, whether you’re building:

Customer support chatbots.
Intelligent search systems.
AI-powered assistants for e-commerce, healthcare, or education.

Built for Developers

Quick Start: Set up your environment, define routes, and go live in just a few steps.
Customization: Tailor the behavior with decorators and fine-tune performance for your specific needs.
Easy LLM Integration: Switch between supported LLMs like OpenAI or Gemini with minimal effort.

How Does ChatsAPI Work?

At its core, ChatsAPI operates through a three-step process:

Register Routes: Use the @trigger decorator to define routes and associate them with your functions.
Search and Match: ChatsAPI uses SBERT embeddings and BM25 Hybrid Search to match user inputs with the right routes dynamically.
Extract Parameters: With the @extract decorator, ChatsAPI automatically extracts and validates parameters, making it easier to handle complex inputs.

The result? A system that’s fast, accurate, and ridiculously easy to use.

Use Cases

Customer Support
Automate customer interactions with blazing-fast query resolution. ChatsAPI ensures users get relevant answers instantly, improving satisfaction and reducing operational costs.
Knowledge Base Search
Empower users to search vast knowledge bases with semantic understanding. The hybrid SBERT-BM25 approach ensures accurate, context-aware results.
Conversational AI
Build conversational AI agents that understand and adapt to user inputs in real-time. ChatsAPI integrates seamlessly with top LLMs to deliver natural, engaging conversations.

Why Should You Care?

Other frameworks promise flexibility or performance — but none can deliver both like ChatsAPI. We’ve created a framework that’s:

Faster than anything else in the market.
Simpler to set up and use.
Smarter, with its unique hybrid search engine that blends semantic and keyword-based approaches.

ChatsAPI empowers developers to unlock the full potential of AI, without the headaches of complexity or slow performance.

How to Get Started

Getting started with ChatsAPI is easy:

Install the framework:

pip install chatsapi

Define your routes:

from chatsapi import ChatsAPI  

chat = ChatsAPI()  

@chat.trigger("Hello")  
async def greet(input_text):  
    return "Hi there!"

Extract some data from the message

from chatsapi import ChatsAPI  

chat = ChatsAPI()  

@chat.trigger("Need help with account settings.")
@chat.extract([
    ("account_number", "Account number (a nine digit number)", int, None),
    ("holder_name", "Account holder's name (a person name)", str, None)
])
async def account_help(chat_message: str, extracted: dict):
    return {"message": chat_message, "extracted": extracted}
Run your message (with no LLM)
@app.post("/chat")
async def message(request: RequestModel, response: Response):
    reply = await chat.run(request.message)
    return {"message": reply}

Conversations (with LLM) — Full Example

import os
from dotenv import load_dotenv
from fastapi import FastAPI, Request, Response
from pydantic import BaseModel
from chatsapi.chatsapi import ChatsAPI

# Load environment variables from .env file
load_dotenv()

app = FastAPI()                 # instantiate FastAPI or your web framework
chat = ChatsAPI(                # instantiate ChatsAPI
    llm_type="gemini",
    llm_model="models/gemini-pro",
    llm_api_key=os.getenv("GOOGLE_API_KEY"),
)

# chat trigger - 1
@chat.trigger("Want to cancel a credit card.")
@chat.extract([("card_number", "Credit card number (a 12 digit number)", str, None)])
async def cancel_credit_card(chat_message: str, extracted: dict):
    return {"message": chat_message, "extracted": extracted}

# chat trigger - 2
@chat.trigger("Need help with account settings.")
@chat.extract([
    ("account_number", "Account number (a nine digit number)", int, None),
    ("holder_name", "Account holder's name (a person name)", str, None)
])
async def account_help(chat_message: str, extracted: dict):
    return {"message": chat_message, "extracted": extracted}

# request model
class RequestModel(BaseModel):
    message: str

# chat conversation
@app.post("/chat")
async def message(request: RequestModel, response: Response, http_request: Request):
    session_id = http_request.cookies.get("session_id")
    reply = await chat.conversation(request.message, session_id)

    return {"message": f"{reply}"}

# set chat session
@app.post("/set-session")
def set_session(response: Response):
    session_id = chat.set_session()
    response.set_cookie(key="session_id", value=session_id)
    return {"message": "Session set"}

# end chat session
@app.post("/end-session")
def end_session(response: Response, http_request: Request):
    session_id = http_request.cookies.get("session_id")
    chat.end_session(session_id)
    response.delete_cookie("session_id")
    return {"message": "Session ended"}

Routes adhering LLM queries — Single Query

await chat.query(request.message)

Benchmarks

Traditional LLM (API)-based methods typically take around four seconds per request. In contrast, ChatsAPI processes requests in under one second, often within milliseconds, without making any LLM API calls.

Performing a chat routing task within 472ms (no cache)

Performing a chat routing task within 21ms (after cache)

Performing a chat routing + data extraction task within 862ms (no cache)

Demonstrating its conversational abilities with WhatsApp Cloud API

ChatsAPI — Feature Hierarchy

ChatsAPI is more than just a framework; it’s a paradigm shift in how we build and interact with AI systems. By combining speed, accuracy, and ease of use, ChatsAPI sets a new benchmark for AI agent frameworks.

Join the revolution today and see why ChatsAPI is transforming the AI landscape.

Ready to dive in? Get started with ChatsAPI now and experience the future of AI development.

ChatWithSQL, The world's most secure and reliable Python library for querying SQL databases through LLMs.

Sathnindu Kottage — Wed, 04 Dec 2024 13:31:59 +0000

ChatWithSQL — Secure, Schema-Validated Text-to-SQL Python Library, Eliminating Arbitrary Query Risks from LLMs

Sathnindu Kottage ・ Dec 4

#python #sql #ai #programming

ChatWithSQL — Secure, Schema-Validated Text-to-SQL Python Library, Eliminating Arbitrary Query Risks from LLMs

Sathnindu Kottage — Wed, 04 Dec 2024 13:30:20 +0000

Library: https://pypi.org/project/chatwithsql
GitHub: https://github.com/sathninduk/chatwithsql

As software evolves, the demand for intuitive, secure, and efficient database interaction grows exponentially. Enter ChatWithSQL, a groundbreaking Python library that transforms how LLMs interact with SQL databases. By combining Natural Language Processing (NLP) with schema-validated SQL generation and data retrieval, ChatWithSQL sets a new benchmark for secure and efficient data retrieval via LLMs.

🌟 What Makes ChatWithSQL Unique?

Text-to-SQL tools are not new, but most have a glaring flaw: the potential to generate and execute arbitrary queries. This poses critical risks:

Unauthorized data access.
SQL injection vulnerabilities.
Query inefficiencies.

ChatWithSQL redefines safety and reliability by implementing a schema-based validation approach. By ensuring all queries adhere to a predefined schema, the library eliminates unauthorized access while maintaining unparalleled performance.

🗺️ Architecture

🔒 Security Beyond Compare

Unlike traditional Text-to-SQL systems, ChatWithSQL validates each query against strict schema definitions before execution, ensuring:

No arbitrary SQL queries.
Comprehensive parameter sanitization and validation.
A secure pipeline that mitigates malicious input risks.

This security-first approach positions ChatWithSQL as the go-to solution for developers seeking both simplicity and trustworthiness.

🚀 Key Features

1. Intuitive Natural Language Interface

Write prompts like:

“Show me the details of the user with ID 5.”
“Show me all the orders on 25th November 2024”
“What is the Birth Day of user ID 34”
“What are the orders higher than USD 500?”

And let ChatWithSQL handle the rest, converting it into actionable SQL.

2. Robust Schema Validation

Define exactly what queries are permissible:

query_schema = [
    {
        "description": "Fetch user data by ID",
        "name": "get_user_data",
        "sql": "SELECT * FROM users WHERE id = ?",
        "params": {"id": {"type": "int", "default": None}},
    },
]

Only queries within this schema are executed, eliminating risks of misuse.

3. Seamless Integration with Top LLMs

ChatWithSQL supports leading Language Learning Models (LLMs), including:

OpenAI: GPT-4, GPT-3.5
Gemini
LlamaAPI
Ollama

Switching between these LLMs is as simple as a configuration change.

4. Dynamic Query Parameters

ChatWithSQL dynamically extracts, validates, and maps query parameters to ensure accurate results every time.

5. Database Agnostic

Whether you’re using PostgreSQL, MySQL, SQLite, or any other SQL database, ChatWithSQL supports it via a universal URI format.

6. Built-In Observability

With detailed logging, ChatWithSQL makes debugging a breeze:

Spot malformed prompts.
Validate query construction.
Track every interaction with your database.

📦 Quick Installation and Setup

Install ChatWithSQL

pip install chatwithsql

Initialize Your Instance

from chat_with_sql import ChatWithSQL
chat_with_sql = ChatWithSQL(
    database_url="your_database_url",
    llm="openai",
    model="gpt-3.5-turbo",
    llm_api_key="your_llm_api_key",
    query_schema=[
        {
            "description": "Fetch user by ID",
            "name": "get_user",
            "sql": "SELECT * FROM users WHERE id = ?",
            "params": {"id": {"type": "int", "default": None}},
        },
    ],
)

Execute a Query

response = chat_with_sql.load_data("Get user details for ID 10.")
print(response)

🔧 Designed for Developers, Built for Scale

Use Cases

Analytics Dashboards: Enable non-technical teams to query databases securely.
Enterprise Applications: Add intelligent query capabilities to apps while maintaining strict controls.
Data Exploration: Empower analysts with natural language access to structured data.

Advanced Query Schema Example

query_schema = [
    {
        "description": "Fetch user details by date of birth",
        "name": "get_user_by_dob",
        "sql": "SELECT * FROM users WHERE dob = ?",
        "params": {"dob": {"type": "date", "default": None}},
    },
    {
        "description": "Count orders by status",
        "name": "count_orders_by_status",
        "sql": "SELECT COUNT(*) FROM orders WHERE status = ?",
        "params": {"status": {"type": "str", "default": "pending"}},
    },
]

🌐 Why Developers Love ChatWithSQL

Security: No other Text-to-SQL solution offers such rigorous validation.
Flexibility: Use it with your favorite LLMs and databases.
Simplicity: A single library that transforms natural language into database power.

🛣️ Roadmap

Currently, ChatWithSQL supports only SELECT queries, but there are plans to extend support to other SQL operations, including INSERT, UPDATE, and DELETE.

Additionally, this library is the first component of a broader initiative to develop a comprehensive, free, and open-source framework for AI Chat Agents. This framework addresses a significant business need in the nowadays software engineering industry by simplifying complex requirements into a few simple steps.

🤝 Join the ChatWithSQL Revolution

Ready to experience the next level of database interaction? Start using ChatWithSQL today, and empower your applications with intelligent, secure, and efficient query handling.

GitHub Repository: ChatWithSQL
Support Email: hello@bysatha.com

Contribute and Collaborate

We welcome contributions! Submit pull requests or report issues to help shape the future of ChatWithSQL.

With ChatWithSQL, natural language meets SQL in a way that’s secure, reliable, and game-changing. Join the movement, and take your applications to the next level today!