This is page 1 of 2. Use http://codebase.md/deepspringai/search_mcp_server?format=md&page={x} to view the full context.

# Directory Structure

```
├── .chainlit
│   ├── config.toml
│   └── translations
│       ├── bn.json
│       ├── en-US.json
│       ├── gu.json
│       ├── he-IL.json
│       ├── hi.json
│       ├── ja.json
│       ├── kn.json
│       ├── ml.json
│       ├── mr.json
│       ├── nl.json
│       ├── ta.json
│       ├── te.json
│       └── zh-CN.json
├── .gitignore
├── .python-version
├── chainlit.md
├── Dockerfile
├── embedding_server.log
├── final_response_output.txt
├── pyproject.toml
├── README.md
├── smithery.yaml
├── src
│   ├── parquet_mcp_server
│   │   ├── __init__.py
│   │   ├── chainlit.md
│   │   ├── chatAgent.py
│   │   ├── client.py
│   │   ├── main.py
│   │   └── src
│   │       ├── search_helper.py
│   │       └── supabase_db.py
│   └── tests
│       ├── test_search.py
│       └── test_similarity.py
└── uv.lock
```

# Files

--------------------------------------------------------------------------------
/.python-version:
--------------------------------------------------------------------------------

```
3.12

```

--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------

```
# Python-generated files
__pycache__/
*.py[oc]
build/
dist/
wheels/
*.egg-info
.venv 
venv
# Virtual environments
.venv
.env
*.parquet

*.log
src/parquet_mcp_server/*.log
src/parquet_mcp_server/.chainlit/
src/parquet_mcp_server/output.json

temp/
output.json
tmp/

```

--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------

```markdown
# parquet_mcp_server
[![smithery badge](https://smithery.ai/badge/@DeepSpringAI/parquet_mcp_server)](https://smithery.ai/server/@DeepSpringAI/parquet_mcp_server)

A powerful MCP (Model Control Protocol) server that provides tools for performing web searches and finding similar content. This server is designed to work with Claude Desktop and offers two main functionalities:

1. **Web Search**: Perform a web search and scrape results
2. **Similarity Search**: Extract relevant information from previous searches

This server is particularly useful for:
- Applications requiring web search capabilities
- Projects needing to find similar content based on search queries

## Installation

### Installing via Smithery

To install Parquet MCP Server for Claude Desktop automatically via [Smithery](https://smithery.ai/server/@DeepSpringAI/parquet_mcp_server):

```bash
npx -y @smithery/cli install @DeepSpringAI/parquet_mcp_server --client claude
```

### Clone this repository

```bash
git clone ...
cd parquet_mcp_server
```

### Create and activate virtual environment

```bash
uv venv
.venv\Scripts\activate  # On Windows
source .venv/bin/activate  # On macOS/Linux
```

### Install the package

```bash
uv pip install -e .
```

### Environment

Create a `.env` file with the following variables:

```bash
EMBEDDING_URL=http://sample-url.com/api/embed  # URL for the embedding service
OLLAMA_URL=http://sample-url.com/  # URL for Ollama server
EMBEDDING_MODEL=sample-model  # Model to use for generating embeddings
SEARCHAPI_API_KEY=your_searchapi_api_key
FIRECRAWL_API_KEY=your_firecrawl_api_key
VOYAGE_API_KEY=your_voyage_api_key
AZURE_OPENAI_ENDPOINT=http://sample-url.com/azure_openai
AZURE_OPENAI_API_KEY=your_azure_openai_api_key
```

## Usage with Claude Desktop

Add this to your Claude Desktop configuration file (`claude_desktop_config.json`):

```json
{
  "mcpServers": {
    "parquet-mcp-server": {
      "command": "uv",
      "args": [
        "--directory",
        "/home/${USER}/workspace/parquet_mcp_server/src/parquet_mcp_server",
        "run",
        "main.py"
      ]
    }
  }
}
```

## Available Tools

The server provides two main tools:

1. **Search Web**: Perform a web search and scrape results
   - Required parameters:
     - `queries`: List of search queries
   - Optional parameters:
     - `page_number`: Page number for the search results (defaults to 1)

2. **Extract Info from Search**: Extract relevant information from previous searches
   - Required parameters:
     - `queries`: List of search queries to merge

## Example Prompts

Here are some example prompts you can use with the agent:

### For Web Search:
```
"Please perform a web search for 'macbook' and 'laptop' and scrape the results from page 1"
```

### For Extracting Info from Search:
```
"Please extract relevant information from the previous searches for 'macbook'"
```

## Testing the MCP Server

The project includes a comprehensive test suite in the `src/tests` directory. You can run all tests using:

```bash
python src/tests/run_tests.py
```

Or run individual tests:

```bash
# Test Web Search
python src/tests/test_search_web.py

# Test Extract Info from Search
python src/tests/test_extract_info_from_search.py
```

You can also test the server using the client directly:

```python
from parquet_mcp_server.client import (
    perform_search_and_scrape,  # New web search function
    find_similar_chunks  # New extract info function
)

# Perform a web search
perform_search_and_scrape(["macbook", "laptop"], page_number=1)

# Extract information from the search results
find_similar_chunks(["macbook"])
```

### Troubleshooting

1. If you get SSL verification errors, make sure the SSL settings in your `.env` file are correct
2. If embeddings are not generated, check:
   - The Ollama server is running and accessible
   - The model specified is available on your Ollama server
   - The text column exists in your input Parquet file
3. If DuckDB conversion fails, check:
   - The input Parquet file exists and is readable
   - You have write permissions in the output directory
   - The Parquet file is not corrupted
4. If PostgreSQL conversion fails, check:
   - The PostgreSQL connection settings in your `.env` file are correct
   - The PostgreSQL server is running and accessible
   - You have the necessary permissions to create/modify tables
   - The pgvector extension is installed in your database

## PostgreSQL Function for Vector Similarity Search

To perform vector similarity searches in PostgreSQL, you can use the following function:

```sql
-- Create the function for vector similarity search
CREATE OR REPLACE FUNCTION match_web_search(
  query_embedding vector(1024),  -- Adjusted vector size
  match_threshold float,
  match_count int  -- User-defined limit for number of results
)
RETURNS TABLE (
  id bigint,
  metadata jsonb,
  text TEXT,  -- Added text column to the result
  date TIMESTAMP,  -- Using the date column instead of created_at
  similarity float
)
LANGUAGE plpgsql
AS $$
BEGIN
  RETURN QUERY
  SELECT
    web_search.id,
    web_search.metadata,
    web_search.text,  -- Returning the full text of the chunk
    web_search.date,  -- Returning the date timestamp
    1 - (web_search.embedding <=> query_embedding) as similarity
  FROM web_search
  WHERE 1 - (web_search.embedding <=> query_embedding) > match_threshold
  ORDER BY web_search.date DESC,  -- Sort by date in descending order (newest first)
           web_search.embedding <=> query_embedding  -- Sort by similarity
  LIMIT match_count;  -- Limit the results to the match_count specified by the user
END;
$$;
```

This function allows you to perform similarity searches on vector embeddings stored in a PostgreSQL database, returning results that meet a specified similarity threshold and limiting the number of results based on user input. The results are sorted by date and similarity.



## Postgres table creation
```
CREATE TABLE web_search (
    id SERIAL PRIMARY KEY,
    text TEXT,
    metadata JSONB,
    embedding VECTOR(1024),

    -- This will be auto-updated
    date TIMESTAMP DEFAULT NOW()
);
```
```

--------------------------------------------------------------------------------
/src/parquet_mcp_server/__init__.py:
--------------------------------------------------------------------------------

```python

```

--------------------------------------------------------------------------------
/src/tests/test_similarity.py:
--------------------------------------------------------------------------------

```python
import sys
import os
from parquet_mcp_server.client import find_similar_chunks

def test_find_similar_chunks():
    """Test the find similar chunks functionality"""
    try:
        # Example test data
        test_data = {
            "queries": ["macbook"]
        }
        
        # Call the find similar chunks function
        result = find_similar_chunks(
            queries=test_data["queries"]
        )
        
        
        return result  # Return the success status
        
    except Exception as e:
        print(f"Find Similar Chunks Test Error: {str(e)}")
        return False

if __name__ == "__main__":
    result = test_find_similar_chunks()
    print(result)

```

--------------------------------------------------------------------------------
/src/tests/test_search.py:
--------------------------------------------------------------------------------

```python
import json
import sys
import os
from parquet_mcp_server.client import perform_search_and_scrape

def test_search_and_scrape():
    """Test the search and scrape functionality"""
    try:
        # Example test data
        test_data = {
            "queries": ["macbook"],
        }
        
        # Call the search and scrape function
        result = perform_search_and_scrape(
            queries=test_data["queries"],
        )
        
        return result  # Return the success status
        
    except Exception as e:
        print(f"Search and Scrape Test Error: {str(e)}")
        return False

if __name__ == "__main__":
    success = test_search_and_scrape()
    sys.exit(0 if success else 1) 
```

--------------------------------------------------------------------------------
/chainlit.md:
--------------------------------------------------------------------------------

```markdown
# Welcome to Chainlit! 🚀🤖

Hi there, Developer! 👋 We're excited to have you on board. Chainlit is a powerful tool designed to help you prototype, debug and share applications built on top of LLMs.

## Useful Links 🔗

- **Documentation:** Get started with our comprehensive [Chainlit Documentation](https://docs.chainlit.io) 📚
- **Discord Community:** Join our friendly [Chainlit Discord](https://discord.gg/k73SQ3FyUh) to ask questions, share your projects, and connect with other developers! 💬

We can't wait to see what you create with Chainlit! Happy coding! 💻😊

## Welcome screen

To modify the welcome screen, edit the `chainlit.md` file at the root of your project. If you do not want a welcome screen, just leave this file empty.

```

--------------------------------------------------------------------------------
/src/parquet_mcp_server/chainlit.md:
--------------------------------------------------------------------------------

```markdown
# Welcome to Chainlit! 🚀🤖

Hi there, Developer! 👋 We're excited to have you on board. Chainlit is a powerful tool designed to help you prototype, debug and share applications built on top of LLMs.

## Useful Links 🔗

- **Documentation:** Get started with our comprehensive [Chainlit Documentation](https://docs.chainlit.io) 📚
- **Discord Community:** Join our friendly [Chainlit Discord](https://discord.gg/k73SQ3FyUh) to ask questions, share your projects, and connect with other developers! 💬

We can't wait to see what you create with Chainlit! Happy coding! 💻😊

## Welcome screen

To modify the welcome screen, edit the `chainlit.md` file at the root of your project. If you do not want a welcome screen, just leave this file empty.

```

--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------

```dockerfile
# Use Python 3.8 as base image
FROM python:3.8-slim

# Set working directory
WORKDIR /app

# Install system dependencies
RUN apt-get update && apt-get install -y \
    build-essential \
    libpq-dev \
    && rm -rf /var/lib/apt/lists/*

# Install uv for Python package management
RUN pip install uv

# Copy the project files
COPY . .

# Create and activate virtual environment
RUN uv venv
ENV PATH="/app/.venv/bin:$PATH"

# Install the project and its dependencies
RUN uv pip install -e .

# Set environment variables with default values
ENV OLLAMA_URL=""
ENV EMBEDDING_URL=""
ENV EMBEDDING_MODEL="nomic-embed-text"
ENV POSTGRES_DB=""
ENV POSTGRES_USER=""
ENV POSTGRES_PASSWORD=""
ENV POSTGRES_HOST=""
ENV POSTGRES_PORT="5432"

# Use bash as the entrypoint
ENTRYPOINT ["/bin/bash"]

```

--------------------------------------------------------------------------------
/pyproject.toml:
--------------------------------------------------------------------------------

```toml
[project]
name = "parquet_mcp_server"
version = "0.1.0"
description = "A server that provides tools for manipulating and analyzing Parquet files"
authors = [
    { name = "Your Name", email = "your.email@example.com" },
]
dependencies = [
    "mcp",
    "pyarrow",
    "pandas",
    "numpy",
    "requests",
    "langchain",
    "langgraph",
    "langchain-ollama",
    "chainlit",
    "streamlit",
    "duckdb",
    "psycopg2-binary",
    "markdown",
    "beautifulsoup4",
    "clear>=2.0.0",
    "firecrawl-py>=1.16.0",
    "langchain-mcp-adapters>=0.0.7",
    "langchain-openai>=0.3.12",
    "autogen-ext>=0.5.3",
    "autogen-core>=0.5.3",
    "supabase>=2.15.0",
]
requires-python = ">=3.10"

[build-system]
requires = ["hatchling"]
build-backend = "hatchling.build"

[tool.hatch.build.targets.wheel]
packages = ["src/parquet_mcp_server"]

```

--------------------------------------------------------------------------------
/smithery.yaml:
--------------------------------------------------------------------------------

```yaml
# Smithery configuration file: https://smithery.ai/docs/config#smitheryyaml

build:
  dockerfile: Dockerfile
  dockerBuildPath: .
startCommand:
  type: stdio
  configSchema:
    # JSON Schema defining the configuration options for the MCP.
    type: object
    required:
      - ollama_url
      - embedding_url
      - embedding_model
    properties:
      ollama_url:
        type: string
        description: URL for the Ollama server
      postgres_db:
        type: string
        description: PostgreSQL database name
      embedding_url:
        type: string
        description: URL for the embedding service
      postgres_host:
        type: string
        description: PostgreSQL host
      postgres_port:
        type: string
        description: PostgreSQL port
      postgres_user:
        type: string
        description: PostgreSQL username
      embedding_model:
        type: string
        description: Model to use for generating embeddings
      postgres_password:
        type: string
        description: PostgreSQL password
  commandFunction:
    # A JS function that produces the CLI command based on the given config to start the MCP on stdio.
    |-
    (config) => ({
      "command": "uv",
      "args": [
        "--directory",
        "./src/parquet_mcp_server",
        "run",
        "main.py"
      ],
      "env": {
        "OLLAMA_URL": config.ollama_url,
        "EMBEDDING_URL": config.embedding_url,
        "EMBEDDING_MODEL": config.embedding_model,
        "POSTGRES_DB": config.postgres_db || "",
        "POSTGRES_USER": config.postgres_user || "",
        "POSTGRES_PASSWORD": config.postgres_password || "",
        "POSTGRES_HOST": config.postgres_host || "",
        "POSTGRES_PORT": config.postgres_port || "5432"
      }
    })

```

--------------------------------------------------------------------------------
/src/parquet_mcp_server/main.py:
--------------------------------------------------------------------------------

```python
from mcp.server import NotificationOptions, Server
from mcp.server.models import InitializationOptions
from typing import Any, Optional
from dotenv import load_dotenv
import pyarrow.parquet as pq
import mcp.types as types
import mcp.server.stdio
import pandas as pd
import numpy as np 
import requests
import asyncio
import json
import os
import logging

from parquet_mcp_server.src.search_helper import perform_search_and_scrape, find_similar_chunks

# Set up logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s'
)

# Initialize server
server = Server("parquet-tools")

@server.list_tools()
async def handle_list_tools() -> list[types.Tool]:
    """List available parquet manipulation tools."""
    return [
        types.Tool(
            name="search-web",
            description="Perform a web search and scrape results",
            inputSchema={
                "type": "object",
                "properties": {
                    "queries": {
                        "type": "array",
                        "items": {
                            "type": "string"
                        },
                        "description": "List of search queries"
                    },
                    "page_number": {
                        "type": "integer",
                        "description": "Page number for the search results"
                    }
                },
                "required": ["queries"]
            }
        ),
        types.Tool(
            name="extract-info-from-search",
            description="Extract relative information from previous searches",
            inputSchema={
                "type": "object",
                "properties": {
                    "queries": {
                        "type": "array",
                        "items": {
                            "type": "string"
                        },
                        "description": "List of search queries to merge"
                    },
                },
                "required": ["queries"]
            }
        ),
    ]

@server.call_tool()
async def handle_call_tool(
    name: str, arguments: dict | None
) -> list[types.TextContent | types.ImageContent | types.EmbeddedResource]:
    """Handle parquet tool execution requests."""
    if not arguments:
        raise ValueError("Missing arguments")
    
    if name == "search-web":
        queries = arguments.get("queries")
        page_number = arguments.get("page_number", 1)  # Default to page 1 if not provided
        
        if not queries:
            raise ValueError("Missing queries argument")

        success, message = await perform_search_and_scrape(queries, page_number)
        return [types.TextContent(type="text", text=message)]

    elif name == "extract-info-from-search":
        queries = arguments.get("queries")

        if not queries:
            raise ValueError("Missing queries argument")

        logging.info(f"Starting extract-info-from-search with queries: {queries}")
        success, message = await find_similar_chunks(queries)
        logging.info(f"Extract-info-from-search completed with success: {success}")
        return [types.TextContent(type="text", text=message)]

    else:
        raise ValueError(f"Unknown tool: {name}")

async def main():
    """Run the server using stdin/stdout streams."""
    async with mcp.server.stdio.stdio_server() as (read_stream, write_stream):
        await server.run(
            read_stream,
            write_stream,
            InitializationOptions(
                server_name="search-tools",
                server_version="0.1.0",
                capabilities=server.get_capabilities(
                    notification_options=NotificationOptions(),
                    experimental_capabilities={},
                ),
            ),
        )

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

```

--------------------------------------------------------------------------------
/.chainlit/config.toml:
--------------------------------------------------------------------------------

```toml
[project]
# Whether to enable telemetry (default: true). No personal data is collected.
enable_telemetry = true


# List of environment variables to be provided by each user to use the app.
user_env = []

# Duration (in seconds) during which the session is saved when the connection is lost
session_timeout = 3600

# Duration (in seconds) of the user session expiry
user_session_timeout = 1296000  # 15 days

# Enable third parties caching (e.g., LangChain cache)
cache = false

# Authorized origins
allow_origins = ["*"]

[features]
# Process and display HTML in messages. This can be a security risk (see https://stackoverflow.com/questions/19603097/why-is-it-dangerous-to-render-user-generated-html-or-javascript)
unsafe_allow_html = false

# Process and display mathematical expressions. This can clash with "$" characters in messages.
latex = false

# Autoscroll new user messages at the top of the window
user_message_autoscroll = true

# Automatically tag threads with the current chat profile (if a chat profile is used)
auto_tag_thread = true

# Allow users to edit their own messages
edit_message = true

# Authorize users to spontaneously upload files with messages
[features.spontaneous_file_upload]
    enabled = true
    # Define accepted file types using MIME types
    # Examples:
    # 1. For specific file types:
    #    accept = ["image/jpeg", "image/png", "application/pdf"]
    # 2. For all files of certain type:
    #    accept = ["image/*", "audio/*", "video/*"]
    # 3. For specific file extensions:
    #    accept = { "application/octet-stream" = [".xyz", ".pdb"] }
    # Note: Using "*/*" is not recommended as it may cause browser warnings
    accept = ["*/*"]
    max_files = 20
    max_size_mb = 500

[features.audio]
    # Sample rate of the audio
    sample_rate = 24000

[features.mcp.sse]
    enabled = true

[features.mcp.stdio]
    enabled = true
    # Only the executables in the allow list can be used for MCP stdio server.
    # Only need the base name of the executable, e.g. "npx", not "/usr/bin/npx".
    # Please don't comment this line for now, we need it to parse the executable name.
    allowed_executables = [ "npx", "uvx" ]

[UI]
# Name of the assistant.
name = "Assistant"

# default_theme = "dark"

# layout = "wide"

# default_sidebar_state = "open"

# Description of the assistant. This is used for HTML tags.
# description = ""

# Chain of Thought (CoT) display mode. Can be "hidden", "tool_call" or "full".
cot = "full"

# Specify a CSS file that can be used to customize the user interface.
# The CSS file can be served from the public directory or via an external link.
# custom_css = "/public/test.css"

# Specify additional attributes for a custom CSS file
# custom_css_attributes = "media=\"print\""

# Specify a JavaScript file that can be used to customize the user interface.
# The JavaScript file can be served from the public directory.
# custom_js = "/public/test.js"

# Specify additional attributes for custom JS file
# custom_js_attributes = "async type = \"module\""

# Custom login page image, relative to public directory or external URL
# login_page_image = "/public/custom-background.jpg"

# Custom login page image filter (Tailwind internal filters, no dark/light variants)
# login_page_image_filter = "brightness-50 grayscale"
# login_page_image_dark_filter = "contrast-200 blur-sm"

# Specify a custom meta image url.
# custom_meta_image_url = "https://chainlit-cloud.s3.eu-west-3.amazonaws.com/logo/chainlit_banner.png"

# Specify a custom build directory for the frontend.
# This can be used to customize the frontend code.
# Be careful: If this is a relative path, it should not start with a slash.
# custom_build = "./public/build"

# Specify optional one or more custom links in the header.
# [[UI.header_links]]
#     name = "Issues"
#     display_name = "Report Issue"
#     icon_url = "https://avatars.githubusercontent.com/u/128686189?s=200&v=4"
#     url = "https://github.com/Chainlit/chainlit/issues"

[meta]
generated_by = "2.5.5"

```

--------------------------------------------------------------------------------
/src/parquet_mcp_server/src/supabase_db.py:
--------------------------------------------------------------------------------

```python
import os
from dotenv import load_dotenv
from supabase import create_client, Client
import numpy as np
from typing import Dict, List, Any, Optional

# Load environment variables
load_dotenv()

class SupabaseDB:
    def __init__(self):
        """Initialize Supabase client with environment variables."""
        url: str = os.environ.get("SUPABASE_URL")
        key: str = os.environ.get("SUPABASE_KEY")
        self.supabase: Client = create_client(url, key)

    def add_new_data(self, data: Dict[str, Any]) -> Dict[str, Any]:
        """
        Add new data to the web_search table.
        
        Args:
            data: Dictionary containing text, metadata, and embedding
            
        Returns:
            Dict containing the inserted data or error information
        """
        try:
            # Extract URL and search_id from metadata (assuming metadata is a dictionary)
            url_to_delete = data.get("metadata", {}).get("url")
            new_search_id = data.get("metadata", {}).get("search_id")

            if url_to_delete and new_search_id:
                # Step 1: Get rows with the same URL and check that search_id is different
                response = self.supabase.table('web_search').select("id, metadata").filter('metadata->>url', 'eq', url_to_delete).execute()

                rows_to_delete = []
                for row in response.data:
                    # Check if the search_id is different in the existing row
                    existing_search_id = row['metadata'].get('search_id')
                    if existing_search_id != new_search_id:
                        rows_to_delete.append(row['id'])

                if rows_to_delete:
                    # Step 2: Delete rows with the same URL and different search_id
                    delete_response = self.supabase.table('web_search').delete().in_('id', rows_to_delete).execute()

                    # If there's an error with deletion, raise an exception
                    if 'error' in delete_response:
                        raise Exception(f"Failed to delete old data: {delete_response['error']}")
                    
                # Step 3: Insert new data
                insert_response = self.supabase.table('web_search').insert(data).execute()

                # If there's an error with insertion, raise an exception
                if 'error' in insert_response:
                    raise Exception(f"Failed to insert new data: {insert_response['error']}")

                return {"success": True, "data": insert_response.data}
            else:
                raise Exception("URL or search_id not found in the provided data metadata.")

        except Exception as e:
            raise Exception(f"Failed to insert data into Supabase: {str(e)}")

    def get_top_10_results(self) -> Dict[str, Any]:
        """
        Get top 10 results from the web_search table.
        
        Returns:
            Dict containing the results or error information
        """
        try:
            response = self.supabase.table('web_search').select(
                "id, metadata, text, embedding"
            ).limit(10).execute()
            return {"success": True, "data": response.data}
        except Exception as e:
            return {"success": False, "error": str(e)}

    def search_results_by_similarity(
        self, 
        query_embedding: List[float], 
        threshold: float = 0.55, 
        match_count: int = 10
    ) -> Dict[str, Any]:
        """
        Search results by similarity using the match_web_search RPC function.
        
        Args:
            query_embedding: The embedding vector to search with
            threshold: Similarity threshold (default: 0.55)
            match_count: Number of matches to return (default: 10)
            
        Returns:
            Dict containing the search results or error information
        """
        try:
            response = self.supabase.rpc(
                'match_web_search',
                {
                    'query_embedding': query_embedding,
                    'match_threshold': threshold,
                    'match_count': match_count
                }
            ).execute()
            return {"success": True, "data": response.data}
        except Exception as e:
            return {"success": False, "error": str(e)}

# Example usage
if __name__ == "__main__":
    # Initialize the database client
    db = SupabaseDB()
    
    # Example data
    sample_data = {
        "text": "This is a sample chunk of text from a web search result.",
        "metadata": {
            "title": "Sample Web Search Result",
            "search_id": "2",
            "url": "https://example.com",
            "description": "This is a sample web search result",
            "timestamp": "2024-03-20T12:00:00Z"
        },
        "embedding": np.random.rand(1024).tolist()
    }
    
    # Example query embedding
    query_embedding = np.random.rand(1024).tolist()
    
    # Add new data
    insert_result = db.add_new_data(sample_data)
    
    # # Get top 10 results
    # top_results = db.get_top_10_results()
    
    # # Search results by similarity
    # similarity_results = db.search_results_by_similarity(
    #     query_embedding, 
    #     threshold=0.55, 
    #     match_count=10
    # )

    # print(similarity_results)

```

--------------------------------------------------------------------------------
/src/parquet_mcp_server/client.py:
--------------------------------------------------------------------------------

```python
from langchain_core.messages import HumanMessage, ToolMessage, AIMessage
from langchain_openai import AzureChatOpenAI
from langchain_mcp_adapters.tools import load_mcp_tools
from mcp import ClientSession, StdioServerParameters
from langgraph.prebuilt import create_react_agent
from mcp.client.stdio import stdio_client
from langchain_ollama import ChatOllama
from dotenv import load_dotenv
import asyncio
import json
import os 
import logging


load_dotenv()

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    handlers=[
        logging.StreamHandler()
    ]
)


# Initialize Ollama LangChain model
model = ChatOllama(
    base_url=os.getenv("OLLAMA_URL"),
    model="llama3.1:8b",
)

openai_model = AzureChatOpenAI(
    azure_deployment="gpt-4o-mini",  # or your deployment
    api_version="2024-08-01-preview",  # or your api version
)



server_params = StdioServerParameters(
    command="uv",
    args=[
        "--directory", os.getenv("SERVER_DIRECTORY", "./src/parquet_mcp_server"),
        "run", os.getenv("MAIN_SCRIPT", "main.py")
    ],
    env={
        "EMBEDDING_URL": os.getenv("EMBEDDING_URL"),
        "OLLAMA_URL": os.getenv("OLLAMA_URL"),
        "EMBEDDING_MODEL": os.getenv("EMBEDDING_MODEL"),
        "SEARCHAPI_API_KEY": os.getenv("SEARCHAPI_API_KEY"),
        "FIRECRAWL_API_KEY": os.getenv("FIRECRAWL_API_KEY"),
    }
)

async def main():
    async with stdio_client(server_params) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()

            tools = await load_mcp_tools(session)
            agent = create_react_agent(model, tools)

            print("🔁 Interactive Agent Started. Type 'exit' to stop.")
            while True:
                user_input = input("\n🧑‍💻 Your query: ")
                if user_input.strip().lower() == "exit":
                    print("👋 Exiting.")
                    break
                # user_input = "قیمت ایفون ۱۳ از سرچ قبلی بکش بیرون"

                conversation = [HumanMessage(content=user_input)]

                while True:
                    response = await agent.ainvoke({"messages": conversation})
                    new_messages = response["messages"]
                    conversation.extend(new_messages)

                    print("\n--- 💬 New Messages ---")
                    tool_result = None
                    tool_function_name = None

                    for msg in new_messages:
                        role = "**User**" if isinstance(msg, HumanMessage) else "**AI**" if isinstance(msg, AIMessage) else "**Tool**"

                        if isinstance(msg.content, list):
                            for c in msg.content:
                                if role != "**Tool**":
                                    print(f"{role}: {c.get('text', '')}")
                        else:
                            if role != "**Tool**":
                                print(f"{role}: {msg.content}")

                        # Tool call detection
                        if isinstance(msg, AIMessage) and msg.tool_calls:
                            for tool_call in msg.tool_calls:
                                print(f"🔧 AI is calling tool: {tool_call['name']} with arguments: {tool_call['args']}")
                                tool_function_name = tool_call["name"]

                        # Tool response
                        if isinstance(msg, ToolMessage):
                            tool_result = msg
                            print(f"{role} (tool output preview): {msg.content[:20]}...")  # Preview

                    # 🧠 Use Ollama LLM directly for 'extract-info-from-search'
                    if tool_result:
                        prompt_content = f"Here is the user's query: {user_input}\nAnd here is the extracted information from the internet. Please organize the information based on the user's query and include the source links: \n{tool_result.content}"
                        print(prompt_content)
                        print("\n--- 🧠 Using OpenAI to extract info ---")

                        final_response = await model.ainvoke([HumanMessage(content=prompt_content)])

                        print("\n--- ✅ Final Answer ---")
                        print("**AI (Azure OpenAI)**:", final_response.content)
                        break

                    break

            


async def perform_search_and_scrape_async(queries: list[str], page_number: int = 1) -> tuple[bool, str]:
    """
    Process a markdown file into chunks and save as parquet
    
    Args:
        queries (list[str]): List of search queries
        page_number (int, optional): Page number for the search results
    
    Returns:
        tuple[bool, str]: Success status and message with output location
    """
    server_params = StdioServerParameters(
        command="uv",
        args=["--directory", "./src/parquet_mcp_server", "run", "main.py"],
    )

    async with stdio_client(server_params) as (read, write):
        async with ClientSession(read, write) as session:
            # Initialize the connection
            await session.initialize()

            # Call the process-markdown tool
            result = await session.call_tool(
                "search-web",
                {
                    "queries": queries,
                    "page_number": page_number
                }
            )
            return result
            

def perform_search_and_scrape(queries: list[str], page_number: int = 1) -> tuple[bool, str]:
    """
    Perform a web search and scrape results (synchronous version)
    
    Args:
        queries (list[str]): List of search queries
        page_number (int, optional): Page number for the search results
    
    Returns:
        tuple[bool, str]: Success status and message with output location
    """
    return asyncio.run(perform_search_and_scrape_async(queries, page_number))

async def find_similar_chunks_async(queries: list[str]):
    server_params = StdioServerParameters(
        command="uv",
        args=["--directory", "./src/parquet_mcp_server", "run", "main.py"],
    )

    async with stdio_client(server_params) as (read, write):
        async with ClientSession(read, write) as session:
            # Initialize the connection
            await session.initialize()

            # Call the find-similar-chunks tool
            result = await session.call_tool(
                "extract-info-from-search",
                {
                    "queries": queries,
                }
            )
            return result

def find_similar_chunks(queries: list[str]):
    """
    Find similar chunks based on a merged query and a JSON file of embeddings
    
    Args:
        queries (list[str]): List of search queries to merge
    
    Returns:
        The result of the similarity search
    """
    return asyncio.run(find_similar_chunks_async(queries))

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


```

--------------------------------------------------------------------------------
/.chainlit/translations/en-US.json:
--------------------------------------------------------------------------------

```json
{
    "common": {
        "actions": {
            "cancel": "Cancel",
            "confirm": "Confirm",
            "continue": "Continue",
            "goBack": "Go Back",
            "reset": "Reset",
            "submit": "Submit"
        },
        "status": {
            "loading": "Loading...",
            "error": {
                "default": "An error occurred",
                "serverConnection": "Could not reach the server"
            }
        }
    },
    "auth": {
        "login": {
            "title": "Login to access the app",
            "form": {
                "email": {
                    "label": "Email address",
                    "required": "email is a required field"
                },
                "password": {
                    "label": "Password",
                    "required": "password is a required field"
                },
                "actions": {
                    "signin": "Sign In"
                },
                "alternativeText": {
                    "or": "OR"
                }
            },
            "errors": {
                "default": "Unable to sign in",
                "signin": "Try signing in with a different account",
                "oauthSignin": "Try signing in with a different account",
                "redirectUriMismatch": "The redirect URI is not matching the oauth app configuration",
                "oauthCallback": "Try signing in with a different account",
                "oauthCreateAccount": "Try signing in with a different account",
                "emailCreateAccount": "Try signing in with a different account",
                "callback": "Try signing in with a different account",
                "oauthAccountNotLinked": "To confirm your identity, sign in with the same account you used originally",
                "emailSignin": "The e-mail could not be sent",
                "emailVerify": "Please verify your email, a new email has been sent",
                "credentialsSignin": "Sign in failed. Check the details you provided are correct",
                "sessionRequired": "Please sign in to access this page"
            }
        },
        "provider": {
            "continue": "Continue with {{provider}}"
        }
    },
    "chat": {
        "input": {
            "placeholder": "Type your message here...",
            "actions": {
                "send": "Send message",
                "stop": "Stop Task",
                "attachFiles": "Attach files"
            }
        },
        "speech": {
            "start": "Start recording",
            "stop": "Stop recording",
            "connecting": "Connecting"
        },
        "fileUpload": {
            "dragDrop": "Drag and drop files here",
            "browse": "Browse Files",
            "sizeLimit": "Limit:",
            "errors": {
                "failed": "Failed to upload",
                "cancelled": "Cancelled upload of"
            }
        },
        "messages": {
            "status": {
                "using": "Using",
                "used": "Used"
            },
            "actions": {
                "copy": {
                    "button": "Copy to clipboard",
                    "success": "Copied!"
                }
            },
            "feedback": {
                "positive": "Helpful",
                "negative": "Not helpful",
                "edit": "Edit feedback",
                "dialog": {
                    "title": "Add a comment",
                    "submit": "Submit feedback"
                },
                "status": {
                    "updating": "Updating",
                    "updated": "Feedback updated"
                }
            }
        },
        "history": {
            "title": "Last Inputs",
            "empty": "Such empty...",
            "show": "Show history"
        },
        "settings": {
            "title": "Settings panel"
        },
        "watermark": "Built with"
    },
    "threadHistory": {
        "sidebar": {
            "title": "Past Chats",
            "filters": {
                "search": "Search",
                "placeholder": "Search conversations..."
            },
            "timeframes": {
                "today": "Today",
                "yesterday": "Yesterday",
                "previous7days": "Previous 7 days",
                "previous30days": "Previous 30 days"
            },
            "empty": "No threads found",
            "actions": {
                "close": "Close sidebar",
                "open": "Open sidebar"
            }
        },
        "thread": {
            "untitled": "Untitled Conversation",
            "menu": {
                "rename": "Rename",
                "delete": "Delete"
            },
            "actions": {
                "delete": {
                    "title": "Confirm deletion",
                    "description": "This will delete the thread as well as its messages and elements. This action cannot be undone",
                    "success": "Chat deleted",
                    "inProgress": "Deleting chat"
                },
                "rename": {
                    "title": "Rename Thread",
                    "description": "Enter a new name for this thread",
                    "form": {
                        "name": {
                            "label": "Name",
                            "placeholder": "Enter new name"
                        }
                    },
                    "success": "Thread renamed!",
                    "inProgress": "Renaming thread"
                }
            }
        }
    },
    "navigation": {
        "header": {
            "chat": "Chat",
            "readme": "Readme",
            "theme": {
                "light": "Light Theme",
                "dark": "Dark Theme",
                "system": "Follow System"
            }
        },
        "newChat": {
            "button": "New Chat",
            "dialog": {
                "title": "Create New Chat",
                "description": "This will clear your current chat history. Are you sure you want to continue?",
                "tooltip": "New Chat"
            }
        },
        "user": {
            "menu": {
                "settings": "Settings",
                "settingsKey": "S",
                "apiKeys": "API Keys",
                "logout": "Logout"
            }
        }
    },
    "apiKeys": {
        "title": "Required API Keys",
        "description": "To use this app, the following API keys are required. The keys are stored on your device's local storage.",
        "success": {
            "saved": "Saved successfully"
        }
    },
    "alerts": {
        "info": "Info",
        "note": "Note",
        "tip": "Tip",
        "important": "Important",
        "warning": "Warning",
        "caution": "Caution",
        "debug": "Debug",
        "example": "Example",
        "success": "Success",
        "help": "Help",
        "idea": "Idea",
        "pending": "Pending",
        "security": "Security",
        "beta": "Beta",
        "best-practice": "Best Practice"
    }
}
```

--------------------------------------------------------------------------------
/src/parquet_mcp_server/chatAgent.py:
--------------------------------------------------------------------------------

```python
import asyncio
import os
from dotenv import load_dotenv
from typing import cast

import chainlit as cl
from autogen_agentchat.agents import AssistantAgent, UserProxyAgent
from autogen_agentchat.base import TaskResult
from autogen_agentchat.conditions import TextMentionTermination
from autogen_agentchat.messages import ModelClientStreamingChunkEvent, TextMessage
from autogen_agentchat.teams import RoundRobinGroupChat
from autogen_core import CancellationToken
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_ext.tools.mcp import StdioServerParams, mcp_server_tools

import logging
from autogen_core import TRACE_LOGGER_NAME, EVENT_LOGGER_NAME, ROOT_LOGGER_NAME

# Silence all logs
logging.getLogger(TRACE_LOGGER_NAME).setLevel(logging.CRITICAL + 1)
logging.getLogger(EVENT_LOGGER_NAME).setLevel(logging.CRITICAL + 1)
logging.getLogger(ROOT_LOGGER_NAME).setLevel(logging.ERROR)



from autogen_ext.auth.azure import AzureTokenProvider
from autogen_ext.models.openai import AzureOpenAIChatCompletionClient
from azure.identity import DefaultAzureCredential

load_dotenv()

az_model_client = AzureOpenAIChatCompletionClient(
    azure_deployment="gpt-4o-mini",
    model="gpt-4o-mini",
    api_version=os.getenv("AZURE_OPENAI_VERSION"),
    azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"),
    api_key=os.getenv("AZURE_OPENAI_API_KEY"), # For key-based authentication.
)



# Base model for demonstration
model = OpenAIChatCompletionClient(
    model="llama3.1:8b",
    base_url=os.getenv("BASE_OLLAMA_URL"),
    api_key="ollama",
    model_info={
        "model": "llama3.1:8b",
        "vision": False,
        "function_calling": True,
        "json_output": False,
        "family": "unknown",
    },
)

# Define server parameters
server_params = StdioServerParams(
    command="uv",
    args=[
        "--directory",
        "/home/agent/workspace/search_mcp_server/src/parquet_mcp_server",
        "run",
        "main.py",
    ],
)





# User input function
async def user_input_func(prompt: str, cancellation_token: CancellationToken | None = None) -> str:
    try:
        response = await cl.AskUserMessage(content=prompt).send()
    except TimeoutError:
        return "User did not provide any input within the time limit."
    return response["output"] if response else "User did not provide any input."



# Recreate team dynamically based on user-selected mode
async def recreate_team_based_on_mode() -> RoundRobinGroupChat:
    mode = cl.user_session.get("mode", "scratch")
    tools = await mcp_server_tools(server_params)

    if mode == "scratch":
        print("==================================")
        fetcher_system = """
        You are a web search assistant. 
        Pass user prompt to mcp_server and get results.
        Pass All information along with their sources at the end to summerizer.
        """
    else:  # "previous"
        fetcher_system = """
        You are a retriver, get data from previous searches do not search or scrape anything.
        Pass All information along with their sources at the end to summerizer.
        """

    fetcher = AssistantAgent(
        name="fetcher",
        system_message=fetcher_system,
        model_client=az_model_client,
        # OpenAIChatCompletionClient(model="gpt-4o-mini"),
        # az_model_client,
        tools=tools,
        reflect_on_tool_use=True,
        model_client_stream=True,
    )

    summarizer = AssistantAgent(
        name="summarizer",
        system_message="""
        1. Format the 'fetcher' information in a readable table, focusing on key details like prices and specifications.
        2. DO NOT GIVE INFO FROM YOURSELF.
        3. Return the pricing in both Iran and globally based on the fetcher results.
        4. DO NOT CONVERT PRICES TO EACH OTHER. ONLY ADD PRICES YOU ACTUALLY GET.
        5. After completing the above steps, hand off the conversation to the user.
        """,
        model_client=az_model_client,
        # az_model_client,
        # OpenAIChatCompletionClient(model="gpt-4o-mini"),
        model_client_stream=True,
    )

    user = UserProxyAgent(name="user", input_func=user_input_func)
    termination = TextMentionTermination("TERMINATE", sources=["user"])

    return RoundRobinGroupChat([fetcher, summarizer, user], termination_condition=termination)

# Streaming logic
async def run_agent_stream(user_message: str):
    loading_message = await cl.Message(content="Processing... Please wait.", author="system").send()

    team = await recreate_team_based_on_mode()
    cl.user_session.set("team", team)  # optionally update session
    streaming_response: cl.Message | None = None

    try:
        async for msg in team.run_stream(
            task=[TextMessage(content=user_message, source="user")],
            cancellation_token=CancellationToken(),
        ):
            if isinstance(msg, ModelClientStreamingChunkEvent):
                if streaming_response is None:
                    streaming_response = cl.Message(content="", author=msg.source)
                await streaming_response.stream_token(msg.content)
            elif streaming_response is not None:
                await streaming_response.send()
                streaming_response = None
            elif isinstance(msg, TaskResult):
                final_message = "Task terminated. "
                if msg.stop_reason:
                    final_message += msg.stop_reason
                await cl.Message(content=final_message).send()

    finally:
        # Once the task is complete, remove the "Processing..." message
        if loading_message:
            loading_message.content = "Processing complete! Task finished."
            await loading_message.update()



# Initial chat start: shows feature options
@cl.on_chat_start
async def start_chat() -> None:
    actions = [
        cl.Action(name="search_from_scratch", label="Search from Scratch", icon="🔍", payload={"option": "scratch"}),
        cl.Action(name="check_previous_results", label="Check Previous Results", icon="🕘", payload={"option": "previous"})
    ]
    await cl.Message(content="Hi👋, please choose one of the features.", actions=actions).send()
    cl.user_session.set("mode", "scratch")  # default mode

# Handle action: Search from Scratch
@cl.action_callback("search_from_scratch")
async def handle_search_from_scratch(action: cl.Action):
    cl.user_session.set("mode", "scratch")
    response = await cl.AskUserMessage(content="Please enter the product name you want to search for like this  'product x price, قیمت محصول ایکس' .").send()
    if response and response.get("output"):
        await run_agent_stream(response["output"])

# Handle action: Check Previous Results
@cl.action_callback("check_previous_results")
async def handle_check_previous_results(action: cl.Action):
    cl.user_session.set("mode", "previous")
    response = await cl.AskUserMessage(content="I will fetch results from your previous searches. Please enter the product name like this  'product x price, قیمت محصول ایکس' .").send()
    if response and response.get("output"):
        await run_agent_stream(response["output"])

# Catch all for free-form user messages
@cl.on_message
async def chat(message: cl.Message) -> None:
    await run_agent_stream(message.content)

```

--------------------------------------------------------------------------------
/.chainlit/translations/nl.json:
--------------------------------------------------------------------------------

```json
{
    "common": {
        "actions": {
            "cancel": "Annuleren",
            "confirm": "Bevestigen",
            "continue": "Doorgaan",
            "goBack": "Terug",
            "reset": "Herstellen",
            "submit": "Versturen"
        },
        "status": {
            "loading": "Laden...",
            "error": {
                "default": "Er is een fout opgetreden",
                "serverConnection": "Kon geen verbinding maken met de server"
            }
        }
    },
    "auth": {
        "login": {
            "title": "Inloggen om toegang te krijgen tot de app",
            "form": {
                "email": {
                    "label": "E-mailadres",
                    "required": "e-mail is een verplicht veld"
                },
                "password": {
                    "label": "Wachtwoord",
                    "required": "wachtwoord is een verplicht veld"
                },
                "actions": {
                    "signin": "Inloggen"
                },
                "alternativeText": {
                    "or": "OF"
                }
            },
            "errors": {
                "default": "Kan niet inloggen",
                "signin": "Probeer in te loggen met een ander account",
                "oauthSignin": "Probeer in te loggen met een ander account",
                "redirectUriMismatch": "De redirect URI komt niet overeen met de oauth app configuratie",
                "oauthCallback": "Probeer in te loggen met een ander account",
                "oauthCreateAccount": "Probeer in te loggen met een ander account",
                "emailCreateAccount": "Probeer in te loggen met een ander account",
                "callback": "Probeer in te loggen met een ander account",
                "oauthAccountNotLinked": "Om je identiteit te bevestigen, log in met hetzelfde account dat je oorspronkelijk hebt gebruikt",
                "emailSignin": "De e-mail kon niet worden verzonden",
                "emailVerify": "Verifieer je e-mail, er is een nieuwe e-mail verzonden",
                "credentialsSignin": "Inloggen mislukt. Controleer of de ingevoerde gegevens correct zijn",
                "sessionRequired": "Log in om toegang te krijgen tot deze pagina"
            }
        },
        "provider": {
            "continue": "Doorgaan met {{provider}}"
        }
    },
    "chat": {
        "input": {
            "placeholder": "Typ hier je bericht...",
            "actions": {
                "send": "Bericht versturen",
                "stop": "Taak stoppen",
                "attachFiles": "Bestanden bijvoegen"
            }
        },
        "speech": {
            "start": "Start opname",
            "stop": "Stop opname",
            "connecting": "Verbinden"
        },
        "fileUpload": {
            "dragDrop": "Sleep bestanden hierheen",
            "browse": "Bestanden zoeken",
            "sizeLimit": "Limiet:",
            "errors": {
                "failed": "Uploaden mislukt",
                "cancelled": "Upload geannuleerd van"
            }
        },
        "messages": {
            "status": {
                "using": "In gebruik",
                "used": "Gebruikt"
            },
            "actions": {
                "copy": {
                    "button": "Kopi\u00ebren naar klembord",
                    "success": "Gekopieerd!"
                }
            },
            "feedback": {
                "positive": "Nuttig",
                "negative": "Niet nuttig",
                "edit": "Feedback bewerken",
                "dialog": {
                    "title": "Voeg een opmerking toe",
                    "submit": "Feedback versturen"
                },
                "status": {
                    "updating": "Bijwerken",
                    "updated": "Feedback bijgewerkt"
                }
            }
        },
        "history": {
            "title": "Laatste invoer",
            "empty": "Zo leeg...",
            "show": "Toon geschiedenis"
        },
        "settings": {
            "title": "Instellingenpaneel"
        },
        "watermark": "Gebouwd met"
    },
    "threadHistory": {
        "sidebar": {
            "title": "Eerdere chats",
            "filters": {
                "search": "Zoeken",
                "placeholder": "Search conversations..."
            },
            "timeframes": {
                "today": "Vandaag",
                "yesterday": "Gisteren",
                "previous7days": "Afgelopen 7 dagen",
                "previous30days": "Afgelopen 30 dagen"
            },
            "empty": "Geen gesprekken gevonden",
            "actions": {
                "close": "Zijbalk sluiten",
                "open": "Zijbalk openen"
            }
        },
        "thread": {
            "untitled": "Naamloos gesprek",
            "menu": {
                "rename": "Rename",
                "delete": "Delete"
            },
            "actions": {
                "delete": {
                    "title": "Verwijdering bevestigen",
                    "description": "Dit zal het gesprek en bijbehorende berichten en elementen verwijderen. Deze actie kan niet ongedaan worden gemaakt",
                    "success": "Chat verwijderd",
                    "inProgress": "Chat verwijderen"
                },
                "rename": {
                    "title": "Gesprek hernoemen",
                    "description": "Voer een nieuwe naam in voor dit gesprek",
                    "form": {
                        "name": {
                            "label": "Naam",
                            "placeholder": "Voer nieuwe naam in"
                        }
                    },
                    "success": "Gesprek hernoemd!",
                    "inProgress": "Gesprek hernoemen"
                }
            }
        }
    },
    "navigation": {
        "header": {
            "chat": "Chat",
            "readme": "Leesmij",
            "theme": {
                "light": "Light Theme",
                "dark": "Dark Theme",
                "system": "Follow System"
            }
        },
        "newChat": {
            "button": "Nieuwe chat",
            "dialog": {
                "title": "Nieuwe chat aanmaken",
                "description": "Dit zal je huidige chatgeschiedenis wissen. Weet je zeker dat je door wilt gaan?",
                "tooltip": "Nieuwe chat"
            }
        },
        "user": {
            "menu": {
                "settings": "Instellingen",
                "settingsKey": "I",
                "apiKeys": "API-sleutels",
                "logout": "Uitloggen"
            }
        }
    },
    "apiKeys": {
        "title": "Vereiste API-sleutels",
        "description": "Om deze app te gebruiken zijn de volgende API-sleutels vereist. De sleutels worden opgeslagen in de lokale opslag van je apparaat.",
        "success": {
            "saved": "Succesvol opgeslagen"
        }
    },
    "alerts": {
        "info": "Info",
        "note": "Note",
        "tip": "Tip",
        "important": "Important",
        "warning": "Warning",
        "caution": "Caution",
        "debug": "Debug",
        "example": "Example",
        "success": "Success",
        "help": "Help",
        "idea": "Idea",
        "pending": "Pending",
        "security": "Security",
        "beta": "Beta",
        "best-practice": "Best Practice"
    }
}
```

--------------------------------------------------------------------------------
/.chainlit/translations/zh-CN.json:
--------------------------------------------------------------------------------

```json
{
    "common": {
        "actions": {
            "cancel": "\u53d6\u6d88",
            "confirm": "\u786e\u8ba4",
            "continue": "\u7ee7\u7eed",
            "goBack": "\u8fd4\u56de",
            "reset": "\u91cd\u7f6e",
            "submit": "\u63d0\u4ea4"
        },
        "status": {
            "loading": "\u52a0\u8f7d\u4e2d...",
            "error": {
                "default": "\u53d1\u751f\u9519\u8bef",
                "serverConnection": "\u65e0\u6cd5\u8fde\u63a5\u5230\u670d\u52a1\u5668"
            }
        }
    },
    "auth": {
        "login": {
            "title": "\u767b\u5f55\u4ee5\u8bbf\u95ee\u5e94\u7528",
            "form": {
                "email": {
                    "label": "\u7535\u5b50\u90ae\u7bb1",
                    "required": "\u90ae\u7bb1\u662f\u5fc5\u586b\u9879"
                },
                "password": {
                    "label": "\u5bc6\u7801",
                    "required": "\u5bc6\u7801\u662f\u5fc5\u586b\u9879"
                },
                "actions": {
                    "signin": "\u767b\u5f55"
                },
                "alternativeText": {
                    "or": "\u6216"
                }
            },
            "errors": {
                "default": "\u65e0\u6cd5\u767b\u5f55",
                "signin": "\u8bf7\u5c1d\u8bd5\u4f7f\u7528\u5176\u4ed6\u8d26\u53f7\u767b\u5f55",
                "oauthSignin": "\u8bf7\u5c1d\u8bd5\u4f7f\u7528\u5176\u4ed6\u8d26\u53f7\u767b\u5f55",
                "redirectUriMismatch": "\u91cd\u5b9a\u5411URI\u4e0eOAuth\u5e94\u7528\u914d\u7f6e\u4e0d\u5339\u914d",
                "oauthCallback": "\u8bf7\u5c1d\u8bd5\u4f7f\u7528\u5176\u4ed6\u8d26\u53f7\u767b\u5f55",
                "oauthCreateAccount": "\u8bf7\u5c1d\u8bd5\u4f7f\u7528\u5176\u4ed6\u8d26\u53f7\u767b\u5f55",
                "emailCreateAccount": "\u8bf7\u5c1d\u8bd5\u4f7f\u7528\u5176\u4ed6\u8d26\u53f7\u767b\u5f55",
                "callback": "\u8bf7\u5c1d\u8bd5\u4f7f\u7528\u5176\u4ed6\u8d26\u53f7\u767b\u5f55",
                "oauthAccountNotLinked": "\u4e3a\u786e\u8ba4\u60a8\u7684\u8eab\u4efd\uff0c\u8bf7\u4f7f\u7528\u539f\u59cb\u8d26\u53f7\u767b\u5f55",
                "emailSignin": "\u90ae\u4ef6\u53d1\u9001\u5931\u8d25",
                "emailVerify": "\u8bf7\u9a8c\u8bc1\u60a8\u7684\u90ae\u7bb1\uff0c\u65b0\u7684\u9a8c\u8bc1\u90ae\u4ef6\u5df2\u53d1\u9001",
                "credentialsSignin": "\u767b\u5f55\u5931\u8d25\u3002\u8bf7\u68c0\u67e5\u60a8\u63d0\u4f9b\u7684\u4fe1\u606f\u662f\u5426\u6b63\u786e",
                "sessionRequired": "\u8bf7\u767b\u5f55\u4ee5\u8bbf\u95ee\u6b64\u9875\u9762"
            }
        },
        "provider": {
            "continue": "\u7ee7\u7eed\u4f7f\u7528{{provider}}"
        }
    },
    "chat": {
        "input": {
            "placeholder": "\u5728\u6b64\u8f93\u5165\u60a8\u7684\u6d88\u606f...",
            "actions": {
                "send": "\u53d1\u9001\u6d88\u606f",
                "stop": "\u505c\u6b62\u4efb\u52a1",
                "attachFiles": "\u9644\u52a0\u6587\u4ef6"
            }
        },
        "speech": {
            "start": "\u5f00\u59cb\u5f55\u97f3",
            "stop": "\u505c\u6b62\u5f55\u97f3",
            "connecting": "\u8fde\u63a5\u4e2d"
        },
        "fileUpload": {
            "dragDrop": "\u5c06\u6587\u4ef6\u62d6\u653e\u5230\u8fd9\u91cc",
            "browse": "\u6d4f\u89c8\u6587\u4ef6",
            "sizeLimit": "\u9650\u5236\uff1a",
            "errors": {
                "failed": "\u4e0a\u4f20\u5931\u8d25",
                "cancelled": "\u5df2\u53d6\u6d88\u4e0a\u4f20"
            }
        },
        "messages": {
            "status": {
                "using": "\u4f7f\u7528\u4e2d",
                "used": "\u5df2\u4f7f\u7528"
            },
            "actions": {
                "copy": {
                    "button": "\u590d\u5236\u5230\u526a\u8d34\u677f",
                    "success": "\u5df2\u590d\u5236\uff01"
                }
            },
            "feedback": {
                "positive": "\u6709\u5e2e\u52a9",
                "negative": "\u6ca1\u6709\u5e2e\u52a9",
                "edit": "\u7f16\u8f91\u53cd\u9988",
                "dialog": {
                    "title": "\u6dfb\u52a0\u8bc4\u8bba",
                    "submit": "\u63d0\u4ea4\u53cd\u9988"
                },
                "status": {
                    "updating": "\u66f4\u65b0\u4e2d",
                    "updated": "\u53cd\u9988\u5df2\u66f4\u65b0"
                }
            }
        },
        "history": {
            "title": "\u6700\u8fd1\u8f93\u5165",
            "empty": "\u7a7a\u7a7a\u5982\u4e5f...",
            "show": "\u663e\u793a\u5386\u53f2"
        },
        "settings": {
            "title": "\u8bbe\u7f6e\u9762\u677f"
        },
        "watermark": "\u6280\u672f\u652f\u6301"
    },
    "threadHistory": {
        "sidebar": {
            "title": "\u5386\u53f2\u5bf9\u8bdd",
            "filters": {
                "search": "\u641c\u7d22",
                "placeholder": "\u641c\u7d22\u4f1a\u8bdd..."
            },
            "timeframes": {
                "today": "\u4eca\u5929",
                "yesterday": "\u6628\u5929",
                "previous7days": "\u8fc7\u53bb7\u5929",
                "previous30days": "\u8fc7\u53bb30\u5929"
            },
            "empty": "\u672a\u627e\u5230\u5bf9\u8bdd",
            "actions": {
                "close": "\u5173\u95ed\u4fa7\u8fb9\u680f",
                "open": "\u6253\u5f00\u4fa7\u8fb9\u680f"
            }
        },
        "thread": {
            "untitled": "\u672a\u547d\u540d\u5bf9\u8bdd",
            "menu": {
                "rename": "\u91cd\u547d\u540d",
                "delete": "\u5220\u9664"
            },
            "actions": {
                "delete": {
                    "title": "\u786e\u8ba4\u5220\u9664",
                    "description": "\u8fd9\u5c06\u5220\u9664\u8be5\u5bf9\u8bdd\u53ca\u5176\u6240\u6709\u6d88\u606f\u548c\u5143\u7d20\u3002\u6b64\u64cd\u4f5c\u65e0\u6cd5\u64a4\u9500",
                    "success": "\u5bf9\u8bdd\u5df2\u5220\u9664",
                    "inProgress": "\u6b63\u5728\u5220\u9664\u5bf9\u8bdd"
                },
                "rename": {
                    "title": "\u91cd\u547d\u540d\u5bf9\u8bdd",
                    "description": "\u4e3a\u6b64\u5bf9\u8bdd\u8f93\u5165\u65b0\u540d\u79f0",
                    "form": {
                        "name": {
                            "label": "\u540d\u79f0",
                            "placeholder": "\u8f93\u5165\u65b0\u540d\u79f0"
                        }
                    },
                    "success": "\u5bf9\u8bdd\u5df2\u91cd\u547d\u540d\uff01",
                    "inProgress": "\u6b63\u5728\u91cd\u547d\u540d\u5bf9\u8bdd"
                }
            }
        }
    },
    "navigation": {
        "header": {
            "chat": "\u804a\u5929",
            "readme": "\u8bf4\u660e",
            "theme": {
                "light": "\u6d45\u8272\u4e3b\u9898",
                "dark": "\u6df1\u8272\u4e3b\u9898",
                "system": "\u8ddf\u968f\u7cfb\u7edf"
            }
        },
        "newChat": {
            "button": "\u65b0\u5efa\u5bf9\u8bdd",
            "dialog": {
                "title": "\u521b\u5efa\u65b0\u5bf9\u8bdd",
                "description": "\u8fd9\u5c06\u6e05\u9664\u60a8\u5f53\u524d\u7684\u804a\u5929\u8bb0\u5f55\u3002\u786e\u5b9a\u8981\u7ee7\u7eed\u5417\uff1f",
                "tooltip": "\u65b0\u5efa\u5bf9\u8bdd"
            }
        },
        "user": {
            "menu": {
                "settings": "\u8bbe\u7f6e",
                "settingsKey": "S",
                "apiKeys": "API\u5bc6\u94a5",
                "logout": "\u9000\u51fa\u767b\u5f55"
            }
        }
    },
    "apiKeys": {
        "title": "\u6240\u9700API\u5bc6\u94a5",
        "description": "\u4f7f\u7528\u6b64\u5e94\u7528\u9700\u8981\u4ee5\u4e0bAPI\u5bc6\u94a5\u3002\u8fd9\u4e9b\u5bc6\u94a5\u5b58\u50a8\u5728\u60a8\u8bbe\u5907\u7684\u672c\u5730\u5b58\u50a8\u4e2d\u3002",
        "success": {
            "saved": "\u4fdd\u5b58\u6210\u529f"
        }
    },
    "alerts": {
        "info": "\u4fe1\u606f",
        "note": "\u6ce8\u91ca",
        "tip": "\u63d0\u793a",
        "important": "\u91cd\u8981",
        "warning": "\u8b66\u544a",
        "caution": "\u6ce8\u610f",
        "debug": "\u8c03\u8bd5",
        "example": "\u793a\u4f8b",
        "success": "\u6210\u529f",
        "help": "\u5e2e\u52a9",
        "idea": "\u60f3\u6cd5",
        "pending": "\u5f85\u5904\u7406",
        "security": "\u5b89\u5168",
        "beta": "\u6d4b\u8bd5",
        "best-practice": "\u6700\u4f73\u5b9e\u8df5"
    }
}
```

--------------------------------------------------------------------------------
/.chainlit/translations/ja.json:
--------------------------------------------------------------------------------

```json
{
    "common": {
        "actions": {
            "cancel": "\u30ad\u30e3\u30f3\u30bb\u30eb",
            "confirm": "\u78ba\u8a8d",
            "continue": "\u7d9a\u3051\u308b",
            "goBack": "\u623b\u308b",
            "reset": "\u30ea\u30bb\u30c3\u30c8",
            "submit": "\u9001\u4fe1"
        },
        "status": {
            "loading": "\u8aad\u307f\u8fbc\u307f\u4e2d...",
            "error": {
                "default": "\u30a8\u30e9\u30fc\u304c\u767a\u751f\u3057\u307e\u3057\u305f",
                "serverConnection": "\u30b5\u30fc\u30d0\u30fc\u306b\u63a5\u7d9a\u3067\u304d\u307e\u305b\u3093\u3067\u3057\u305f"
            }
        }
    },
    "auth": {
        "login": {
            "title": "\u30a2\u30d7\u30ea\u306b\u30ed\u30b0\u30a4\u30f3",
            "form": {
                "email": {
                    "label": "\u30e1\u30fc\u30eb\u30a2\u30c9\u30ec\u30b9",
                    "required": "\u30e1\u30fc\u30eb\u30a2\u30c9\u30ec\u30b9\u306f\u5fc5\u9808\u9805\u76ee\u3067\u3059"
                },
                "password": {
                    "label": "\u30d1\u30b9\u30ef\u30fc\u30c9",
                    "required": "\u30d1\u30b9\u30ef\u30fc\u30c9\u306f\u5fc5\u9808\u9805\u76ee\u3067\u3059"
                },
                "actions": {
                    "signin": "\u30b5\u30a4\u30f3\u30a4\u30f3"
                },
                "alternativeText": {
                    "or": "\u307e\u305f\u306f"
                }
            },
            "errors": {
                "default": "\u30b5\u30a4\u30f3\u30a4\u30f3\u3067\u304d\u307e\u305b\u3093",
                "signin": "\u5225\u306e\u30a2\u30ab\u30a6\u30f3\u30c8\u3067\u30b5\u30a4\u30f3\u30a4\u30f3\u3057\u3066\u304f\u3060\u3055\u3044",
                "oauthSignin": "\u5225\u306e\u30a2\u30ab\u30a6\u30f3\u30c8\u3067\u30b5\u30a4\u30f3\u30a4\u30f3\u3057\u3066\u304f\u3060\u3055\u3044",
                "redirectUriMismatch": "\u30ea\u30c0\u30a4\u30ec\u30af\u30c8URI\u304cOAuth\u30a2\u30d7\u30ea\u306e\u8a2d\u5b9a\u3068\u4e00\u81f4\u3057\u307e\u305b\u3093",
                "oauthCallback": "\u5225\u306e\u30a2\u30ab\u30a6\u30f3\u30c8\u3067\u30b5\u30a4\u30f3\u30a4\u30f3\u3057\u3066\u304f\u3060\u3055\u3044",
                "oauthCreateAccount": "\u5225\u306e\u30a2\u30ab\u30a6\u30f3\u30c8\u3067\u30b5\u30a4\u30f3\u30a4\u30f3\u3057\u3066\u304f\u3060\u3055\u3044",
                "emailCreateAccount": "\u5225\u306e\u30a2\u30ab\u30a6\u30f3\u30c8\u3067\u30b5\u30a4\u30f3\u30a4\u30f3\u3057\u3066\u304f\u3060\u3055\u3044",
                "callback": "\u5225\u306e\u30a2\u30ab\u30a6\u30f3\u30c8\u3067\u30b5\u30a4\u30f3\u30a4\u30f3\u3057\u3066\u304f\u3060\u3055\u3044",
                "oauthAccountNotLinked": "\u672c\u4eba\u78ba\u8a8d\u306e\u305f\u3081\u3001\u6700\u521d\u306b\u4f7f\u7528\u3057\u305f\u306e\u3068\u540c\u3058\u30a2\u30ab\u30a6\u30f3\u30c8\u3067\u30b5\u30a4\u30f3\u30a4\u30f3\u3057\u3066\u304f\u3060\u3055\u3044",
                "emailSignin": "\u30e1\u30fc\u30eb\u3092\u9001\u4fe1\u3067\u304d\u307e\u305b\u3093\u3067\u3057\u305f",
                "emailVerify": "\u30e1\u30fc\u30eb\u30a2\u30c9\u30ec\u30b9\u3092\u78ba\u8a8d\u3057\u3066\u304f\u3060\u3055\u3044\u3002\u65b0\u3057\u3044\u30e1\u30fc\u30eb\u304c\u9001\u4fe1\u3055\u308c\u307e\u3057\u305f",
                "credentialsSignin": "\u30b5\u30a4\u30f3\u30a4\u30f3\u306b\u5931\u6557\u3057\u307e\u3057\u305f\u3002\u5165\u529b\u3057\u305f\u60c5\u5831\u304c\u6b63\u3057\u3044\u304b\u78ba\u8a8d\u3057\u3066\u304f\u3060\u3055\u3044",
                "sessionRequired": "\u3053\u306e\u30da\u30fc\u30b8\u306b\u30a2\u30af\u30bb\u30b9\u3059\u308b\u306b\u306f\u30b5\u30a4\u30f3\u30a4\u30f3\u3057\u3066\u304f\u3060\u3055\u3044"
            }
        },
        "provider": {
            "continue": "{{provider}}\u3067\u7d9a\u3051\u308b"
        }
    },
    "chat": {
        "input": {
            "placeholder": "\u30e1\u30c3\u30bb\u30fc\u30b8\u3092\u5165\u529b\u3057\u3066\u304f\u3060\u3055\u3044...",
            "actions": {
                "send": "\u30e1\u30c3\u30bb\u30fc\u30b8\u3092\u9001\u4fe1",
                "stop": "\u30bf\u30b9\u30af\u3092\u505c\u6b62",
                "attachFiles": "\u30d5\u30a1\u30a4\u30eb\u3092\u6dfb\u4ed8"
            }
        },
        "speech": {
            "start": "\u9332\u97f3\u958b\u59cb",
            "stop": "\u9332\u97f3\u505c\u6b62",
            "connecting": "\u63a5\u7d9a\u4e2d"
        },
        "fileUpload": {
            "dragDrop": "\u3053\u3053\u306b\u30d5\u30a1\u30a4\u30eb\u3092\u30c9\u30e9\u30c3\u30b0\uff06\u30c9\u30ed\u30c3\u30d7",
            "browse": "\u30d5\u30a1\u30a4\u30eb\u3092\u53c2\u7167",
            "sizeLimit": "\u5236\u9650\uff1a",
            "errors": {
                "failed": "\u30a2\u30c3\u30d7\u30ed\u30fc\u30c9\u306b\u5931\u6557\u3057\u307e\u3057\u305f",
                "cancelled": "\u30a2\u30c3\u30d7\u30ed\u30fc\u30c9\u3092\u30ad\u30e3\u30f3\u30bb\u30eb\u3057\u307e\u3057\u305f\uff1a"
            }
        },
        "messages": {
            "status": {
                "using": "\u4f7f\u7528\u4e2d",
                "used": "\u4f7f\u7528\u6e08\u307f"
            },
            "actions": {
                "copy": {
                    "button": "\u30af\u30ea\u30c3\u30d7\u30dc\u30fc\u30c9\u306b\u30b3\u30d4\u30fc",
                    "success": "\u30b3\u30d4\u30fc\u3057\u307e\u3057\u305f\uff01"
                }
            },
            "feedback": {
                "positive": "\u5f79\u306b\u7acb\u3063\u305f",
                "negative": "\u5f79\u306b\u7acb\u305f\u306a\u304b\u3063\u305f",
                "edit": "\u30d5\u30a3\u30fc\u30c9\u30d0\u30c3\u30af\u3092\u7de8\u96c6",
                "dialog": {
                    "title": "\u30b3\u30e1\u30f3\u30c8\u3092\u8ffd\u52a0",
                    "submit": "\u30d5\u30a3\u30fc\u30c9\u30d0\u30c3\u30af\u3092\u9001\u4fe1"
                },
                "status": {
                    "updating": "\u66f4\u65b0\u4e2d",
                    "updated": "\u30d5\u30a3\u30fc\u30c9\u30d0\u30c3\u30af\u3092\u66f4\u65b0\u3057\u307e\u3057\u305f"
                }
            }
        },
        "history": {
            "title": "\u6700\u8fd1\u306e\u5165\u529b",
            "empty": "\u4f55\u3082\u3042\u308a\u307e\u305b\u3093...",
            "show": "\u5c65\u6b74\u3092\u8868\u793a"
        },
        "settings": {
            "title": "\u8a2d\u5b9a\u30d1\u30cd\u30eb"
        },
        "watermark": "\u958b\u767a\u5143\uff1a"
    },
    "threadHistory": {
        "sidebar": {
            "title": "\u904e\u53bb\u306e\u30c1\u30e3\u30c3\u30c8",
            "filters": {
                "search": "\u691c\u7d22",
                "placeholder": "Search conversations..."
            },
            "timeframes": {
                "today": "\u4eca\u65e5",
                "yesterday": "\u6628\u65e5",
                "previous7days": "\u904e\u53bb7\u65e5\u9593",
                "previous30days": "\u904e\u53bb30\u65e5\u9593"
            },
            "empty": "\u30b9\u30ec\u30c3\u30c9\u304c\u898b\u3064\u304b\u308a\u307e\u305b\u3093",
            "actions": {
                "close": "\u30b5\u30a4\u30c9\u30d0\u30fc\u3092\u9589\u3058\u308b",
                "open": "\u30b5\u30a4\u30c9\u30d0\u30fc\u3092\u958b\u304f"
            }
        },
        "thread": {
            "untitled": "\u7121\u984c\u306e\u4f1a\u8a71",
            "menu": {
                "rename": "Rename",
                "delete": "Delete"
            },
            "actions": {
                "delete": {
                    "title": "\u524a\u9664\u306e\u78ba\u8a8d",
                    "description": "\u3053\u306e\u30b9\u30ec\u30c3\u30c9\u3068\u305d\u306e\u30e1\u30c3\u30bb\u30fc\u30b8\u3001\u8981\u7d20\u304c\u524a\u9664\u3055\u308c\u307e\u3059\u3002\u3053\u306e\u64cd\u4f5c\u306f\u53d6\u308a\u6d88\u305b\u307e\u305b\u3093",
                    "success": "\u30c1\u30e3\u30c3\u30c8\u3092\u524a\u9664\u3057\u307e\u3057\u305f",
                    "inProgress": "\u30c1\u30e3\u30c3\u30c8\u3092\u524a\u9664\u4e2d"
                },
                "rename": {
                    "title": "\u30b9\u30ec\u30c3\u30c9\u306e\u540d\u524d\u3092\u5909\u66f4",
                    "description": "\u3053\u306e\u30b9\u30ec\u30c3\u30c9\u306e\u65b0\u3057\u3044\u540d\u524d\u3092\u5165\u529b\u3057\u3066\u304f\u3060\u3055\u3044",
                    "form": {
                        "name": {
                            "label": "\u540d\u524d",
                            "placeholder": "\u65b0\u3057\u3044\u540d\u524d\u3092\u5165\u529b"
                        }
                    },
                    "success": "\u30b9\u30ec\u30c3\u30c9\u540d\u3092\u5909\u66f4\u3057\u307e\u3057\u305f\uff01",
                    "inProgress": "\u30b9\u30ec\u30c3\u30c9\u540d\u3092\u5909\u66f4\u4e2d"
                }
            }
        }
    },
    "navigation": {
        "header": {
            "chat": "\u30c1\u30e3\u30c3\u30c8",
            "readme": "\u8aac\u660e\u66f8",
            "theme": {
                "light": "Light Theme",
                "dark": "Dark Theme",
                "system": "Follow System"
            }
        },
        "newChat": {
            "button": "\u65b0\u898f\u30c1\u30e3\u30c3\u30c8",
            "dialog": {
                "title": "\u65b0\u898f\u30c1\u30e3\u30c3\u30c8\u306e\u4f5c\u6210",
                "description": "\u73fe\u5728\u306e\u30c1\u30e3\u30c3\u30c8\u5c65\u6b74\u304c\u30af\u30ea\u30a2\u3055\u308c\u307e\u3059\u3002\u7d9a\u884c\u3057\u307e\u3059\u304b\uff1f",
                "tooltip": "\u65b0\u898f\u30c1\u30e3\u30c3\u30c8"
            }
        },
        "user": {
            "menu": {
                "settings": "\u8a2d\u5b9a",
                "settingsKey": "S",
                "apiKeys": "API\u30ad\u30fc",
                "logout": "\u30ed\u30b0\u30a2\u30a6\u30c8"
            }
        }
    },
    "apiKeys": {
        "title": "\u5fc5\u8981\u306aAPI\u30ad\u30fc",
        "description": "\u3053\u306e\u30a2\u30d7\u30ea\u3092\u4f7f\u7528\u3059\u308b\u306b\u306f\u3001\u4ee5\u4e0b\u306eAPI\u30ad\u30fc\u304c\u5fc5\u8981\u3067\u3059\u3002\u30ad\u30fc\u306f\u304a\u4f7f\u3044\u306e\u30c7\u30d0\u30a4\u30b9\u306e\u30ed\u30fc\u30ab\u30eb\u30b9\u30c8\u30ec\u30fc\u30b8\u306b\u4fdd\u5b58\u3055\u308c\u307e\u3059\u3002",
        "success": {
            "saved": "\u4fdd\u5b58\u304c\u5b8c\u4e86\u3057\u307e\u3057\u305f"
        }
    },
    "alerts": {
        "info": "Info",
        "note": "Note",
        "tip": "Tip",
        "important": "Important",
        "warning": "Warning",
        "caution": "Caution",
        "debug": "Debug",
        "example": "Example",
        "success": "Success",
        "help": "Help",
        "idea": "Idea",
        "pending": "Pending",
        "security": "Security",
        "beta": "Beta",
        "best-practice": "Best Practice"
    }
}
```

--------------------------------------------------------------------------------
/.chainlit/translations/he-IL.json:
--------------------------------------------------------------------------------

```json
{
    "common": {
        "actions": {
            "cancel": "\u05d1\u05d9\u05d8\u05d5\u05dc",
            "confirm": "\u05d0\u05d9\u05e9\u05d5\u05e8",
            "continue": "\u05d4\u05de\u05e9\u05da",
            "goBack": "\u05d7\u05d6\u05d5\u05e8",
            "reset": "\u05d0\u05d9\u05e4\u05d5\u05e1",
            "submit": "\u05e9\u05dc\u05d7"
        },
        "status": {
            "loading": "\u05d8\u05d5\u05e2\u05df...",
            "error": {
                "default": "\u05d0\u05d9\u05e8\u05e2\u05d4 \u05e9\u05d2\u05d9\u05d0\u05d4",
                "serverConnection": "\u05dc\u05d0 \u05e0\u05d9\u05ea\u05df \u05dc\u05d4\u05ea\u05d7\u05d1\u05e8 \u05dc\u05e9\u05e8\u05ea"
            }
        }
    },
    "auth": {
        "login": {
            "title": "\u05d4\u05ea\u05d7\u05d1\u05e8 \u05db\u05d3\u05d9 \u05dc\u05d2\u05e9\u05ea \u05dc\u05d0\u05e4\u05dc\u05d9\u05e7\u05e6\u05d9\u05d4",
            "form": {
                "email": {
                    "label": "\u05db\u05ea\u05d5\u05d1\u05ea \u05d0\u05d9\u05de\u05d9\u05d9\u05dc",
                    "required": "\u05e9\u05d3\u05d4 \u05d4\u05d0\u05d9\u05de\u05d9\u05d9\u05dc \u05d4\u05d5\u05d0 \u05e9\u05d3\u05d4 \u05d7\u05d5\u05d1\u05d4"
                },
                "password": {
                    "label": "\u05e1\u05d9\u05e1\u05de\u05d4",
                    "required": "\u05e9\u05d3\u05d4 \u05d4\u05e1\u05d9\u05e1\u05de\u05d4 \u05d4\u05d5\u05d0 \u05e9\u05d3\u05d4 \u05d7\u05d5\u05d1\u05d4"
                },
                "actions": {
                    "signin": "\u05d4\u05ea\u05d7\u05d1\u05e8"
                },
                "alternativeText": {
                    "or": "\u05d0\u05d5"
                }
            },
            "errors": {
                "default": "\u05dc\u05d0 \u05e0\u05d9\u05ea\u05df \u05dc\u05d4\u05ea\u05d7\u05d1\u05e8",
                "signin": "\u05e0\u05e1\u05d4 \u05dc\u05d4\u05ea\u05d7\u05d1\u05e8 \u05e2\u05dd \u05d7\u05e9\u05d1\u05d5\u05df \u05d0\u05d7\u05e8",
                "oauthSignin": "\u05e0\u05e1\u05d4 \u05dc\u05d4\u05ea\u05d7\u05d1\u05e8 \u05e2\u05dd \u05d7\u05e9\u05d1\u05d5\u05df \u05d0\u05d7\u05e8",
                "redirectUriMismatch": "\u05db\u05ea\u05d5\u05d1\u05ea \u05d4\u05d4\u05e4\u05e0\u05d9\u05d4 \u05d0\u05d9\u05e0\u05d4 \u05ea\u05d5\u05d0\u05de\u05ea \u05d0\u05ea \u05ea\u05e6\u05d5\u05e8\u05ea \u05d0\u05e4\u05dc\u05d9\u05e7\u05e6\u05d9\u05d9\u05ea OAuth",
                "oauthCallback": "\u05e0\u05e1\u05d4 \u05dc\u05d4\u05ea\u05d7\u05d1\u05e8 \u05e2\u05dd \u05d7\u05e9\u05d1\u05d5\u05df \u05d0\u05d7\u05e8",
                "oauthCreateAccount": "\u05e0\u05e1\u05d4 \u05dc\u05d4\u05ea\u05d7\u05d1\u05e8 \u05e2\u05dd \u05d7\u05e9\u05d1\u05d5\u05df \u05d0\u05d7\u05e8",
                "emailCreateAccount": "\u05e0\u05e1\u05d4 \u05dc\u05d4\u05ea\u05d7\u05d1\u05e8 \u05e2\u05dd \u05d7\u05e9\u05d1\u05d5\u05df \u05d0\u05d7\u05e8",
                "callback": "\u05e0\u05e1\u05d4 \u05dc\u05d4\u05ea\u05d7\u05d1\u05e8 \u05e2\u05dd \u05d7\u05e9\u05d1\u05d5\u05df \u05d0\u05d7\u05e8",
                "oauthAccountNotLinked": "\u05db\u05d3\u05d9 \u05dc\u05d0\u05de\u05ea \u05d0\u05ea \u05d6\u05d4\u05d5\u05ea\u05da, \u05d4\u05ea\u05d7\u05d1\u05e8 \u05e2\u05dd \u05d0\u05d5\u05ea\u05d5 \u05d7\u05e9\u05d1\u05d5\u05df \u05d1\u05d5 \u05d4\u05e9\u05ea\u05de\u05e9\u05ea \u05d1\u05de\u05e7\u05d5\u05e8",
                "emailSignin": "\u05dc\u05d0 \u05e0\u05d9\u05ea\u05df \u05d4\u05d9\u05d4 \u05dc\u05e9\u05dc\u05d5\u05d7 \u05d0\u05ea \u05d4\u05d0\u05d9\u05de\u05d9\u05d9\u05dc",
                "emailVerify": "\u05d0\u05e0\u05d0 \u05d0\u05de\u05ea \u05d0\u05ea \u05d4\u05d0\u05d9\u05de\u05d9\u05d9\u05dc \u05e9\u05dc\u05da, \u05e0\u05e9\u05dc\u05d7 \u05d0\u05d9\u05de\u05d9\u05d9\u05dc \u05d7\u05d3\u05e9",
                "credentialsSignin": "\u05d4\u05d4\u05ea\u05d7\u05d1\u05e8\u05d5\u05ea \u05e0\u05db\u05e9\u05dc\u05d4. \u05d1\u05d3\u05d5\u05e7 \u05e9\u05d4\u05e4\u05e8\u05d8\u05d9\u05dd \u05e9\u05d4\u05d6\u05e0\u05ea \u05e0\u05db\u05d5\u05e0\u05d9\u05dd",
                "sessionRequired": "\u05d0\u05e0\u05d0 \u05d4\u05ea\u05d7\u05d1\u05e8 \u05db\u05d3\u05d9 \u05dc\u05d2\u05e9\u05ea \u05dc\u05d3\u05e3 \u05d6\u05d4"
            }
        },
        "provider": {
            "continue": "\u05d4\u05de\u05e9\u05da \u05e2\u05dd {{provider}}"
        }
    },
    "chat": {
        "input": {
            "placeholder": "\u05d4\u05e7\u05dc\u05d3 \u05d0\u05ea \u05d4\u05d4\u05d5\u05d3\u05e2\u05d4 \u05e9\u05dc\u05da \u05db\u05d0\u05df...",
            "actions": {
                "send": "\u05e9\u05dc\u05d7 \u05d4\u05d5\u05d3\u05e2\u05d4",
                "stop": "\u05e2\u05e6\u05d5\u05e8 \u05de\u05e9\u05d9\u05de\u05d4",
                "attachFiles": "\u05e6\u05e8\u05e3 \u05e7\u05d1\u05e6\u05d9\u05dd"
            }
        },
        "speech": {
            "start": "\u05d4\u05ea\u05d7\u05dc \u05d4\u05e7\u05dc\u05d8\u05d4",
            "stop": "\u05e2\u05e6\u05d5\u05e8 \u05d4\u05e7\u05dc\u05d8\u05d4",
            "connecting": "\u05de\u05ea\u05d7\u05d1\u05e8"
        },
        "fileUpload": {
            "dragDrop": "\u05d2\u05e8\u05d5\u05e8 \u05d5\u05e9\u05d7\u05e8\u05e8 \u05e7\u05d1\u05e6\u05d9\u05dd \u05db\u05d0\u05df",
            "browse": "\u05e2\u05d9\u05d9\u05df \u05d1\u05e7\u05d1\u05e6\u05d9\u05dd",
            "sizeLimit": "\u05de\u05d2\u05d1\u05dc\u05d4:",
            "errors": {
                "failed": "\u05d4\u05e2\u05dc\u05d0\u05d4 \u05e0\u05db\u05e9\u05dc\u05d4",
                "cancelled": "\u05d4\u05e2\u05dc\u05d0\u05d4 \u05d1\u05d5\u05d8\u05dc\u05d4 \u05e9\u05dc"
            }
        },
        "messages": {
            "status": {
                "using": "\u05de\u05e9\u05ea\u05de\u05e9 \u05d1",
                "used": "\u05d4\u05e9\u05ea\u05de\u05e9 \u05d1"
            },
            "actions": {
                "copy": {
                    "button": "\u05d4\u05e2\u05ea\u05e7 \u05dc\u05dc\u05d5\u05d7",
                    "success": "\u05d4\u05d5\u05e2\u05ea\u05e7!"
                }
            },
            "feedback": {
                "positive": "\u05de\u05d5\u05e2\u05d9\u05dc",
                "negative": "\u05dc\u05d0 \u05de\u05d5\u05e2\u05d9\u05dc",
                "edit": "\u05e2\u05e8\u05d5\u05da \u05de\u05e9\u05d5\u05d1",
                "dialog": {
                    "title": "\u05d4\u05d5\u05e1\u05e3 \u05ea\u05d2\u05d5\u05d1\u05d4",
                    "submit": "\u05e9\u05dc\u05d7 \u05de\u05e9\u05d5\u05d1"
                },
                "status": {
                    "updating": "\u05de\u05e2\u05d3\u05db\u05df",
                    "updated": "\u05d4\u05de\u05e9\u05d5\u05d1 \u05e2\u05d5\u05d3\u05db\u05df"
                }
            }
        },
        "history": {
            "title": "\u05e7\u05dc\u05d8\u05d9\u05dd \u05d0\u05d7\u05e8\u05d5\u05e0\u05d9\u05dd",
            "empty": "\u05db\u05dc \u05db\u05da \u05e8\u05d9\u05e7...",
            "show": "\u05d4\u05e6\u05d2 \u05d4\u05d9\u05e1\u05d8\u05d5\u05e8\u05d9\u05d4"
        },
        "settings": {
            "title": "\u05e4\u05d0\u05e0\u05dc \u05d4\u05d2\u05d3\u05e8\u05d5\u05ea"
        },
        "watermark": "\u05e0\u05d1\u05e0\u05d4 \u05d1\u05d0\u05de\u05e6\u05e2\u05d5\u05ea"
    },
    "threadHistory": {
        "sidebar": {
            "title": "\u05e6'\u05d0\u05d8\u05d9\u05dd \u05e7\u05d5\u05d3\u05de\u05d9\u05dd",
            "filters": {
                "search": "\u05d7\u05d9\u05e4\u05d5\u05e9",
                "placeholder": "Search conversations..."
            },
            "timeframes": {
                "today": "\u05d4\u05d9\u05d5\u05dd",
                "yesterday": "\u05d0\u05ea\u05de\u05d5\u05dc",
                "previous7days": "7 \u05d9\u05de\u05d9\u05dd \u05d0\u05d7\u05e8\u05d5\u05e0\u05d9\u05dd",
                "previous30days": "30 \u05d9\u05de\u05d9\u05dd \u05d0\u05d7\u05e8\u05d5\u05e0\u05d9\u05dd"
            },
            "empty": "\u05dc\u05d0 \u05e0\u05de\u05e6\u05d0\u05d5 \u05e9\u05d9\u05d7\u05d5\u05ea",
            "actions": {
                "close": "\u05e1\u05d2\u05d5\u05e8 \u05e1\u05e8\u05d2\u05dc \u05e6\u05d3",
                "open": "\u05e4\u05ea\u05d7 \u05e1\u05e8\u05d2\u05dc \u05e6\u05d3"
            }
        },
        "thread": {
            "untitled": "\u05e9\u05d9\u05d7\u05d4 \u05dc\u05dc\u05d0 \u05db\u05d5\u05ea\u05e8\u05ea",
            "menu": {
                "rename": "Rename",
                "delete": "Delete"
            },
            "actions": {
                "delete": {
                    "title": "\u05d0\u05e9\u05e8 \u05de\u05d7\u05d9\u05e7\u05d4",
                    "description": "\u05e4\u05e2\u05d5\u05dc\u05d4 \u05d6\u05d5 \u05ea\u05de\u05d7\u05e7 \u05d0\u05ea \u05d4\u05e9\u05d9\u05d7\u05d4 \u05d5\u05db\u05df \u05d0\u05ea \u05d4\u05d4\u05d5\u05d3\u05e2\u05d5\u05ea \u05d5\u05d4\u05d0\u05dc\u05de\u05e0\u05d8\u05d9\u05dd \u05e9\u05dc\u05d4. \u05dc\u05d0 \u05e0\u05d9\u05ea\u05df \u05dc\u05d1\u05d8\u05dc \u05e4\u05e2\u05d5\u05dc\u05d4 \u05d6\u05d5",
                    "success": "\u05d4\u05e6'\u05d0\u05d8 \u05e0\u05de\u05d7\u05e7",
                    "inProgress": "\u05de\u05d5\u05d7\u05e7 \u05e6'\u05d0\u05d8"
                },
                "rename": {
                    "title": "\u05e9\u05e0\u05d4 \u05e9\u05dd \u05e9\u05d9\u05d7\u05d4",
                    "description": "\u05d4\u05d6\u05df \u05e9\u05dd \u05d7\u05d3\u05e9 \u05dc\u05e9\u05d9\u05d7\u05d4 \u05d6\u05d5",
                    "form": {
                        "name": {
                            "label": "\u05e9\u05dd",
                            "placeholder": "\u05d4\u05d6\u05df \u05e9\u05dd \u05d7\u05d3\u05e9"
                        }
                    },
                    "success": "\u05e9\u05dd \u05d4\u05e9\u05d9\u05d7\u05d4 \u05e9\u05d5\u05e0\u05d4!",
                    "inProgress": "\u05de\u05e9\u05e0\u05d4 \u05e9\u05dd \u05e9\u05d9\u05d7\u05d4"
                }
            }
        }
    },
    "navigation": {
        "header": {
            "chat": "\u05e6'\u05d0\u05d8",
            "readme": "\u05e7\u05e8\u05d0 \u05d0\u05d5\u05ea\u05d9",
            "theme": {
                "light": "Light Theme",
                "dark": "Dark Theme",
                "system": "Follow System"
            }
        },
        "newChat": {
            "button": "\u05e6'\u05d0\u05d8 \u05d7\u05d3\u05e9",
            "dialog": {
                "title": "\u05e6\u05d5\u05e8 \u05e6'\u05d0\u05d8 \u05d7\u05d3\u05e9",
                "description": "\u05e4\u05e2\u05d5\u05dc\u05d4 \u05d6\u05d5 \u05ea\u05e0\u05e7\u05d4 \u05d0\u05ea \u05d4\u05d9\u05e1\u05d8\u05d5\u05e8\u05d9\u05d9\u05ea \u05d4\u05e6'\u05d0\u05d8 \u05d4\u05e0\u05d5\u05db\u05d7\u05d9\u05ea \u05e9\u05dc\u05da. \u05d4\u05d0\u05dd \u05d0\u05ea\u05d4 \u05d1\u05d8\u05d5\u05d7 \u05e9\u05d1\u05e8\u05e6\u05d5\u05e0\u05da \u05dc\u05d4\u05de\u05e9\u05d9\u05da?",
                "tooltip": "\u05e6'\u05d0\u05d8 \u05d7\u05d3\u05e9"
            }
        },
        "user": {
            "menu": {
                "settings": "\u05d4\u05d2\u05d3\u05e8\u05d5\u05ea",
                "settingsKey": "\u05d4",
                "apiKeys": "\u05de\u05e4\u05ea\u05d7\u05d5\u05ea API",
                "logout": "\u05d4\u05ea\u05e0\u05ea\u05e7"
            }
        }
    },
    "apiKeys": {
        "title": "\u05de\u05e4\u05ea\u05d7\u05d5\u05ea API \u05e0\u05d3\u05e8\u05e9\u05d9\u05dd",
        "description": "\u05db\u05d3\u05d9 \u05dc\u05d4\u05e9\u05ea\u05de\u05e9 \u05d1\u05d0\u05e4\u05dc\u05d9\u05e7\u05e6\u05d9\u05d4 \u05d6\u05d5, \u05e0\u05d3\u05e8\u05e9\u05d9\u05dd \u05de\u05e4\u05ea\u05d7\u05d5\u05ea API \u05d4\u05d1\u05d0\u05d9\u05dd. \u05d4\u05de\u05e4\u05ea\u05d7\u05d5\u05ea \u05de\u05d0\u05d5\u05d7\u05e1\u05e0\u05d9\u05dd \u05d1\u05d0\u05d7\u05e1\u05d5\u05df \u05d4\u05de\u05e7\u05d5\u05de\u05d9 \u05e9\u05dc \u05d4\u05de\u05db\u05e9\u05d9\u05e8 \u05e9\u05dc\u05da.",
        "success": {
            "saved": "\u05e0\u05e9\u05de\u05e8 \u05d1\u05d4\u05e6\u05dc\u05d7\u05d4"
        }
    },
    "alerts": {
        "info": "Info",
        "note": "Note",
        "tip": "Tip",
        "important": "Important",
        "warning": "Warning",
        "caution": "Caution",
        "debug": "Debug",
        "example": "Example",
        "success": "Success",
        "help": "Help",
        "idea": "Idea",
        "pending": "Pending",
        "security": "Security",
        "beta": "Beta",
        "best-practice": "Best Practice"
    }
}
```

--------------------------------------------------------------------------------
/.chainlit/translations/gu.json:
--------------------------------------------------------------------------------

```json
{
    "common": {
        "actions": {
            "cancel": "\u0ab0\u0aa6 \u0a95\u0ab0\u0acb",
            "confirm": "\u0aaa\u0ac1\u0ab7\u0acd\u0a9f\u0abf \u0a95\u0ab0\u0acb",
            "continue": "\u0a9a\u0abe\u0ab2\u0ac1 \u0ab0\u0abe\u0a96\u0acb",
            "goBack": "\u0aaa\u0abe\u0a9b\u0abe \u0a9c\u0abe\u0a93",
            "reset": "\u0ab0\u0ac0\u0ab8\u0ac7\u0a9f \u0a95\u0ab0\u0acb",
            "submit": "\u0ab8\u0aac\u0aae\u0abf\u0a9f \u0a95\u0ab0\u0acb"
        },
        "status": {
            "loading": "\u0ab2\u0acb\u0aa1 \u0aa5\u0a88 \u0ab0\u0ab9\u0acd\u0aaf\u0ac1\u0a82 \u0a9b\u0ac7...",
            "error": {
                "default": "\u0a8f\u0a95 \u0aad\u0ac2\u0ab2 \u0aa5\u0a88",
                "serverConnection": "\u0ab8\u0ab0\u0acd\u0ab5\u0ab0 \u0ab8\u0ac1\u0aa7\u0ac0 \u0aaa\u0ab9\u0acb\u0a82\u0a9a\u0ac0 \u0ab6\u0a95\u0abe\u0aaf\u0ac1\u0a82 \u0aa8\u0aa5\u0ac0"
            }
        }
    },
    "auth": {
        "login": {
            "title": "\u0a8f\u0aaa\u0acd\u0ab2\u0abf\u0a95\u0ac7\u0ab6\u0aa8 \u0a8d\u0a95\u0acd\u0ab8\u0ac7\u0ab8 \u0a95\u0ab0\u0ab5\u0abe \u0aae\u0abe\u0a9f\u0ac7 \u0ab2\u0ac9\u0a97\u0abf\u0aa8 \u0a95\u0ab0\u0acb",
            "form": {
                "email": {
                    "label": "\u0a88\u0aae\u0ac7\u0ab2 \u0a8f\u0aa1\u0acd\u0ab0\u0ac7\u0ab8",
                    "required": "\u0a88\u0aae\u0ac7\u0ab2 \u0a86\u0ab5\u0ab6\u0acd\u0aaf\u0a95 \u0a9b\u0ac7"
                },
                "password": {
                    "label": "\u0aaa\u0abe\u0ab8\u0ab5\u0ab0\u0acd\u0aa1",
                    "required": "\u0aaa\u0abe\u0ab8\u0ab5\u0ab0\u0acd\u0aa1 \u0a86\u0ab5\u0ab6\u0acd\u0aaf\u0a95 \u0a9b\u0ac7"
                },
                "actions": {
                    "signin": "\u0ab8\u0abe\u0a87\u0aa8 \u0a87\u0aa8 \u0a95\u0ab0\u0acb"
                },
                "alternativeText": {
                    "or": "\u0a85\u0aa5\u0ab5\u0abe"
                }
            },
            "errors": {
                "default": "\u0ab8\u0abe\u0a87\u0aa8 \u0a87\u0aa8 \u0a95\u0ab0\u0ac0 \u0ab6\u0a95\u0abe\u0aaf\u0ac1\u0a82 \u0aa8\u0aa5\u0ac0",
                "signin": "\u0a85\u0ab2\u0a97 \u0a8f\u0a95\u0abe\u0a89\u0aa8\u0acd\u0a9f\u0aa5\u0ac0 \u0ab8\u0abe\u0a87\u0aa8 \u0a87\u0aa8 \u0a95\u0ab0\u0ab5\u0abe\u0aa8\u0acb \u0aaa\u0acd\u0ab0\u0aaf\u0abe\u0ab8 \u0a95\u0ab0\u0acb",
                "oauthSignin": "\u0a85\u0ab2\u0a97 \u0a8f\u0a95\u0abe\u0a89\u0aa8\u0acd\u0a9f\u0aa5\u0ac0 \u0ab8\u0abe\u0a87\u0aa8 \u0a87\u0aa8 \u0a95\u0ab0\u0ab5\u0abe\u0aa8\u0acb \u0aaa\u0acd\u0ab0\u0aaf\u0abe\u0ab8 \u0a95\u0ab0\u0acb",
                "redirectUriMismatch": "\u0ab0\u0ac0\u0aa1\u0abe\u0aaf\u0ab0\u0ac7\u0a95\u0acd\u0a9f URI oauth \u0a8d\u0aaa \u0a95\u0aa8\u0acd\u0aab\u0abf\u0a97\u0ab0\u0ac7\u0ab6\u0aa8 \u0ab8\u0abe\u0aa5\u0ac7 \u0aae\u0ac7\u0ab3 \u0a96\u0abe\u0aa4\u0acb \u0aa8\u0aa5\u0ac0",
                "oauthCallback": "\u0a85\u0ab2\u0a97 \u0a8f\u0a95\u0abe\u0a89\u0aa8\u0acd\u0a9f\u0aa5\u0ac0 \u0ab8\u0abe\u0a87\u0aa8 \u0a87\u0aa8 \u0a95\u0ab0\u0ab5\u0abe\u0aa8\u0acb \u0aaa\u0acd\u0ab0\u0aaf\u0abe\u0ab8 \u0a95\u0ab0\u0acb",
                "oauthCreateAccount": "\u0a85\u0ab2\u0a97 \u0a8f\u0a95\u0abe\u0a89\u0aa8\u0acd\u0a9f\u0aa5\u0ac0 \u0ab8\u0abe\u0a87\u0aa8 \u0a87\u0aa8 \u0a95\u0ab0\u0ab5\u0abe\u0aa8\u0acb \u0aaa\u0acd\u0ab0\u0aaf\u0abe\u0ab8 \u0a95\u0ab0\u0acb",
                "emailCreateAccount": "\u0a85\u0ab2\u0a97 \u0a8f\u0a95\u0abe\u0a89\u0aa8\u0acd\u0a9f\u0aa5\u0ac0 \u0ab8\u0abe\u0a87\u0aa8 \u0a87\u0aa8 \u0a95\u0ab0\u0ab5\u0abe\u0aa8\u0acb \u0aaa\u0acd\u0ab0\u0aaf\u0abe\u0ab8 \u0a95\u0ab0\u0acb",
                "callback": "\u0a85\u0ab2\u0a97 \u0a8f\u0a95\u0abe\u0a89\u0aa8\u0acd\u0a9f\u0aa5\u0ac0 \u0ab8\u0abe\u0a87\u0aa8 \u0a87\u0aa8 \u0a95\u0ab0\u0ab5\u0abe\u0aa8\u0acb \u0aaa\u0acd\u0ab0\u0aaf\u0abe\u0ab8 \u0a95\u0ab0\u0acb",
                "oauthAccountNotLinked": "\u0aa4\u0aae\u0abe\u0ab0\u0ac0 \u0a93\u0ab3\u0a96\u0aa8\u0ac0 \u0aaa\u0ac1\u0ab7\u0acd\u0a9f\u0abf \u0a95\u0ab0\u0ab5\u0abe \u0aae\u0abe\u0a9f\u0ac7, \u0aae\u0ac2\u0ab3 \u0ab0\u0ac2\u0aaa\u0ac7 \u0ab5\u0abe\u0aaa\u0ab0\u0ac7\u0ab2\u0abe \u0a8f\u0a95\u0abe\u0a89\u0aa8\u0acd\u0a9f\u0aa5\u0ac0 \u0ab8\u0abe\u0a87\u0aa8 \u0a87\u0aa8 \u0a95\u0ab0\u0acb",
                "emailSignin": "\u0a88\u0aae\u0ac7\u0ab2 \u0aae\u0acb\u0a95\u0ab2\u0ac0 \u0ab6\u0a95\u0abe\u0aaf\u0acb \u0aa8\u0aa5\u0ac0",
                "emailVerify": "\u0a95\u0ac3\u0aaa\u0abe \u0a95\u0ab0\u0ac0 \u0aa4\u0aae\u0abe\u0ab0\u0acb \u0a88\u0aae\u0ac7\u0ab2 \u0a9a\u0a95\u0abe\u0ab8\u0acb, \u0aa8\u0ab5\u0acb \u0a88\u0aae\u0ac7\u0ab2 \u0aae\u0acb\u0a95\u0ab2\u0ab5\u0abe\u0aae\u0abe\u0a82 \u0a86\u0ab5\u0acd\u0aaf\u0acb \u0a9b\u0ac7",
                "credentialsSignin": "\u0ab8\u0abe\u0a87\u0aa8 \u0a87\u0aa8 \u0aa8\u0abf\u0ab7\u0acd\u0aab\u0ab3. \u0a86\u0aaa\u0ac7\u0ab2\u0ac0 \u0ab5\u0abf\u0a97\u0aa4\u0acb \u0ab8\u0abe\u0a9a\u0ac0 \u0a9b\u0ac7 \u0a95\u0ac7 \u0aa8\u0ab9\u0ac0\u0a82 \u0aa4\u0ac7 \u0a9a\u0a95\u0abe\u0ab8\u0acb",
                "sessionRequired": "\u0a86 \u0aaa\u0ac7\u0a9c\u0aa8\u0ac7 \u0a8d\u0a95\u0acd\u0ab8\u0ac7\u0ab8 \u0a95\u0ab0\u0ab5\u0abe \u0aae\u0abe\u0a9f\u0ac7 \u0a95\u0ac3\u0aaa\u0abe \u0a95\u0ab0\u0ac0 \u0ab8\u0abe\u0a87\u0aa8 \u0a87\u0aa8 \u0a95\u0ab0\u0acb"
            }
        },
        "provider": {
            "continue": "{{provider}} \u0ab8\u0abe\u0aa5\u0ac7 \u0a9a\u0abe\u0ab2\u0ac1 \u0ab0\u0abe\u0a96\u0acb"
        }
    },
    "chat": {
        "input": {
            "placeholder": "\u0a85\u0ab9\u0ac0\u0a82 \u0aa4\u0aae\u0abe\u0ab0\u0acb \u0ab8\u0a82\u0aa6\u0ac7\u0ab6 \u0ab2\u0a96\u0acb...",
            "actions": {
                "send": "\u0ab8\u0a82\u0aa6\u0ac7\u0ab6 \u0aae\u0acb\u0a95\u0ab2\u0acb",
                "stop": "\u0a95\u0abe\u0ab0\u0acd\u0aaf \u0ab0\u0acb\u0a95\u0acb",
                "attachFiles": "\u0aab\u0abe\u0a87\u0ab2\u0acd\u0ab8 \u0a9c\u0acb\u0aa1\u0acb"
            }
        },
        "speech": {
            "start": "\u0ab0\u0ac7\u0a95\u0acb\u0ab0\u0acd\u0aa1\u0abf\u0a82\u0a97 \u0ab6\u0ab0\u0ac2 \u0a95\u0ab0\u0acb",
            "stop": "\u0ab0\u0ac7\u0a95\u0acb\u0ab0\u0acd\u0aa1\u0abf\u0a82\u0a97 \u0aac\u0a82\u0aa7 \u0a95\u0ab0\u0acb",
            "connecting": "\u0a95\u0aa8\u0ac7\u0a95\u0acd\u0a9f \u0aa5\u0a88 \u0ab0\u0ab9\u0acd\u0aaf\u0ac1\u0a82 \u0a9b\u0ac7"
        },
        "fileUpload": {
            "dragDrop": "\u0a85\u0ab9\u0ac0\u0a82 \u0aab\u0abe\u0a87\u0ab2\u0acd\u0ab8 \u0a96\u0ac7\u0a82\u0a9a\u0acb \u0a85\u0aa8\u0ac7 \u0a9b\u0acb\u0aa1\u0acb",
            "browse": "\u0aab\u0abe\u0a87\u0ab2\u0acd\u0ab8 \u0aac\u0acd\u0ab0\u0abe\u0a89\u0a9d \u0a95\u0ab0\u0acb",
            "sizeLimit": "\u0aae\u0ab0\u0acd\u0aaf\u0abe\u0aa6\u0abe:",
            "errors": {
                "failed": "\u0a85\u0aaa\u0ab2\u0acb\u0aa1 \u0a95\u0ab0\u0ab5\u0abe\u0aae\u0abe\u0a82 \u0aa8\u0abf\u0ab7\u0acd\u0aab\u0ab3",
                "cancelled": "\u0a85\u0aaa\u0ab2\u0acb\u0aa1 \u0ab0\u0aa6 \u0a95\u0ab0\u0acd\u0aaf\u0ac1\u0a82"
            }
        },
        "messages": {
            "status": {
                "using": "\u0ab5\u0abe\u0aaa\u0ab0\u0ac0 \u0ab0\u0ab9\u0acd\u0aaf\u0abe \u0a9b\u0ac7",
                "used": "\u0ab5\u0aaa\u0ab0\u0abe\u0aaf\u0ac7\u0ab2"
            },
            "actions": {
                "copy": {
                    "button": "\u0a95\u0acd\u0ab2\u0abf\u0aaa\u0aac\u0acb\u0ab0\u0acd\u0aa1 \u0aaa\u0ab0 \u0a95\u0ac9\u0aaa\u0abf \u0a95\u0ab0\u0acb",
                    "success": "\u0a95\u0ac9\u0aaa\u0abf \u0aa5\u0aaf\u0ac1\u0a82!"
                }
            },
            "feedback": {
                "positive": "\u0a89\u0aaa\u0aaf\u0acb\u0a97\u0ac0",
                "negative": "\u0aac\u0abf\u0aa8\u0a89\u0aaa\u0aaf\u0acb\u0a97\u0ac0",
                "edit": "\u0aaa\u0acd\u0ab0\u0aa4\u0abf\u0ab8\u0abe\u0aa6 \u0ab8\u0a82\u0aaa\u0abe\u0aa6\u0abf\u0aa4 \u0a95\u0ab0\u0acb",
                "dialog": {
                    "title": "\u0a9f\u0abf\u0aaa\u0acd\u0aaa\u0aa3\u0ac0 \u0a89\u0aae\u0ac7\u0ab0\u0acb",
                    "submit": "\u0aaa\u0acd\u0ab0\u0aa4\u0abf\u0ab8\u0abe\u0aa6 \u0ab8\u0aac\u0aae\u0abf\u0a9f \u0a95\u0ab0\u0acb"
                },
                "status": {
                    "updating": "\u0a85\u0aaa\u0aa1\u0ac7\u0a9f \u0aa5\u0a88 \u0ab0\u0ab9\u0acd\u0aaf\u0ac1\u0a82 \u0a9b\u0ac7",
                    "updated": "\u0aaa\u0acd\u0ab0\u0aa4\u0abf\u0ab8\u0abe\u0aa6 \u0a85\u0aaa\u0aa1\u0ac7\u0a9f \u0aa5\u0aaf\u0acb"
                }
            }
        },
        "history": {
            "title": "\u0a9b\u0ac7\u0ab2\u0acd\u0ab2\u0abe \u0a87\u0aa8\u0aaa\u0ac1\u0a9f\u0acd\u0ab8",
            "empty": "\u0a96\u0abe\u0ab2\u0ac0 \u0a9b\u0ac7...",
            "show": "\u0a87\u0aa4\u0abf\u0ab9\u0abe\u0ab8 \u0aac\u0aa4\u0abe\u0ab5\u0acb"
        },
        "settings": {
            "title": "\u0ab8\u0ac7\u0a9f\u0abf\u0a82\u0a97\u0acd\u0ab8 \u0aaa\u0ac7\u0aa8\u0ab2"
        },
        "watermark": "\u0ab8\u0abe\u0aa5\u0ac7 \u0aac\u0aa8\u0abe\u0ab5\u0ac7\u0ab2"
    },
    "threadHistory": {
        "sidebar": {
            "title": "\u0aaa\u0abe\u0a9b\u0ab2\u0ac0 \u0a9a\u0ac7\u0a9f\u0acd\u0ab8",
            "filters": {
                "search": "\u0ab6\u0acb\u0aa7\u0acb",
                "placeholder": "Search conversations..."
            },
            "timeframes": {
                "today": "\u0a86\u0a9c\u0ac7",
                "yesterday": "\u0a97\u0a88\u0a95\u0abe\u0ab2\u0ac7",
                "previous7days": "\u0aaa\u0abe\u0a9b\u0ab2\u0abe 7 \u0aa6\u0abf\u0ab5\u0ab8",
                "previous30days": "\u0aaa\u0abe\u0a9b\u0ab2\u0abe 30 \u0aa6\u0abf\u0ab5\u0ab8"
            },
            "empty": "\u0a95\u0acb\u0a88 \u0aa5\u0acd\u0ab0\u0ac7\u0aa1\u0acd\u0ab8 \u0aae\u0ab3\u0acd\u0aaf\u0abe \u0aa8\u0aa5\u0ac0",
            "actions": {
                "close": "\u0ab8\u0abe\u0a87\u0aa1\u0aac\u0abe\u0ab0 \u0aac\u0a82\u0aa7 \u0a95\u0ab0\u0acb",
                "open": "\u0ab8\u0abe\u0a87\u0aa1\u0aac\u0abe\u0ab0 \u0a96\u0acb\u0ab2\u0acb"
            }
        },
        "thread": {
            "untitled": "\u0ab6\u0ac0\u0ab0\u0acd\u0ab7\u0a95 \u0ab5\u0a97\u0ab0\u0aa8\u0ac0 \u0ab5\u0abe\u0aa4\u0a9a\u0ac0\u0aa4",
            "menu": {
                "rename": "Rename",
                "delete": "Delete"
            },
            "actions": {
                "delete": {
                    "title": "\u0a95\u0abe\u0aa2\u0ac0 \u0aa8\u0abe\u0a96\u0ab5\u0abe\u0aa8\u0ac0 \u0aaa\u0ac1\u0ab7\u0acd\u0a9f\u0abf \u0a95\u0ab0\u0acb",
                    "description": "\u0a86 \u0aa5\u0acd\u0ab0\u0ac7\u0aa1 \u0a85\u0aa8\u0ac7 \u0aa4\u0ac7\u0aa8\u0abe \u0ab8\u0a82\u0aa6\u0ac7\u0ab6\u0abe\u0a93 \u0a85\u0aa8\u0ac7 \u0aa4\u0aa4\u0acd\u0ab5\u0acb\u0aa8\u0ac7 \u0a95\u0abe\u0aa2\u0ac0 \u0aa8\u0abe\u0a96\u0ab6\u0ac7. \u0a86 \u0a95\u0acd\u0ab0\u0abf\u0aaf\u0abe \u0aaa\u0abe\u0a9b\u0ac0 \u0aab\u0ac7\u0ab0\u0ab5\u0ac0 \u0ab6\u0a95\u0abe\u0ab6\u0ac7 \u0aa8\u0ab9\u0ac0\u0a82",
                    "success": "\u0a9a\u0ac7\u0a9f \u0a95\u0abe\u0aa2\u0ac0 \u0aa8\u0abe\u0a96\u0ac0",
                    "inProgress": "\u0a9a\u0ac7\u0a9f \u0a95\u0abe\u0aa2\u0ac0 \u0aa8\u0abe\u0a96\u0ac0 \u0ab0\u0ab9\u0acd\u0aaf\u0abe \u0a9b\u0ac0\u0a8f"
                },
                "rename": {
                    "title": "\u0aa5\u0acd\u0ab0\u0ac7\u0aa1\u0aa8\u0ac1\u0a82 \u0aa8\u0abe\u0aae \u0aac\u0aa6\u0ab2\u0acb",
                    "description": "\u0a86 \u0aa5\u0acd\u0ab0\u0ac7\u0aa1 \u0aae\u0abe\u0a9f\u0ac7 \u0aa8\u0ab5\u0ac1\u0a82 \u0aa8\u0abe\u0aae \u0aa6\u0abe\u0a96\u0ab2 \u0a95\u0ab0\u0acb",
                    "form": {
                        "name": {
                            "label": "\u0aa8\u0abe\u0aae",
                            "placeholder": "\u0aa8\u0ab5\u0ac1\u0a82 \u0aa8\u0abe\u0aae \u0aa6\u0abe\u0a96\u0ab2 \u0a95\u0ab0\u0acb"
                        }
                    },
                    "success": "\u0aa5\u0acd\u0ab0\u0ac7\u0aa1\u0aa8\u0ac1\u0a82 \u0aa8\u0abe\u0aae \u0aac\u0aa6\u0ab2\u0abe\u0aaf\u0ac1\u0a82!",
                    "inProgress": "\u0aa5\u0acd\u0ab0\u0ac7\u0aa1\u0aa8\u0ac1\u0a82 \u0aa8\u0abe\u0aae \u0aac\u0aa6\u0ab2\u0ac0 \u0ab0\u0ab9\u0acd\u0aaf\u0abe \u0a9b\u0ac0\u0a8f"
                }
            }
        }
    },
    "navigation": {
        "header": {
            "chat": "\u0a9a\u0ac7\u0a9f",
            "readme": "\u0ab5\u0abe\u0a82\u0a9a\u0acb",
            "theme": {
                "light": "Light Theme",
                "dark": "Dark Theme",
                "system": "Follow System"
            }
        },
        "newChat": {
            "button": "\u0aa8\u0ab5\u0ac0 \u0a9a\u0ac7\u0a9f",
            "dialog": {
                "title": "\u0aa8\u0ab5\u0ac0 \u0a9a\u0ac7\u0a9f \u0aac\u0aa8\u0abe\u0ab5\u0acb",
                "description": "\u0a86 \u0aa4\u0aae\u0abe\u0ab0\u0acb \u0ab5\u0ab0\u0acd\u0aa4\u0aae\u0abe\u0aa8 \u0a9a\u0ac7\u0a9f \u0a87\u0aa4\u0abf\u0ab9\u0abe\u0ab8 \u0ab8\u0abe\u0aab \u0a95\u0ab0\u0ab6\u0ac7. \u0ab6\u0ac1\u0a82 \u0aa4\u0aae\u0ac7 \u0a9a\u0abe\u0ab2\u0ac1 \u0ab0\u0abe\u0a96\u0ab5\u0abe \u0aae\u0abe\u0a82\u0a97\u0acb \u0a9b\u0acb?",
                "tooltip": "\u0aa8\u0ab5\u0ac0 \u0a9a\u0ac7\u0a9f"
            }
        },
        "user": {
            "menu": {
                "settings": "\u0ab8\u0ac7\u0a9f\u0abf\u0a82\u0a97\u0acd\u0ab8",
                "settingsKey": "S",
                "apiKeys": "API \u0a95\u0ac0",
                "logout": "\u0ab2\u0ac9\u0a97\u0a86\u0a89\u0a9f"
            }
        }
    },
    "apiKeys": {
        "title": "\u0a9c\u0ab0\u0ac2\u0ab0\u0ac0 API \u0a95\u0ac0",
        "description": "\u0a86 \u0a8f\u0aaa\u0acd\u0ab2\u0abf\u0a95\u0ac7\u0ab6\u0aa8 \u0ab5\u0abe\u0aaa\u0ab0\u0ab5\u0abe \u0aae\u0abe\u0a9f\u0ac7, \u0aa8\u0ac0\u0a9a\u0ac7\u0aa8\u0ac0 API \u0a95\u0ac0 \u0a9c\u0ab0\u0ac2\u0ab0\u0ac0 \u0a9b\u0ac7. \u0a95\u0ac0 \u0aa4\u0aae\u0abe\u0ab0\u0abe \u0aa1\u0abf\u0ab5\u0abe\u0a87\u0ab8\u0aa8\u0abe \u0ab2\u0acb\u0a95\u0ab2 \u0ab8\u0acd\u0a9f\u0acb\u0ab0\u0ac7\u0a9c\u0aae\u0abe\u0a82 \u0ab8\u0a82\u0a97\u0acd\u0ab0\u0ab9\u0abf\u0aa4 \u0aa5\u0ab6\u0ac7.",
        "success": {
            "saved": "\u0ab8\u0aab\u0ab3\u0aa4\u0abe\u0aaa\u0ac2\u0ab0\u0acd\u0ab5\u0a95 \u0ab8\u0abe\u0a9a\u0ab5\u0acd\u0aaf\u0ac1\u0a82"
        }
    },
    "alerts": {
        "info": "Info",
        "note": "Note",
        "tip": "Tip",
        "important": "Important",
        "warning": "Warning",
        "caution": "Caution",
        "debug": "Debug",
        "example": "Example",
        "success": "Success",
        "help": "Help",
        "idea": "Idea",
        "pending": "Pending",
        "security": "Security",
        "beta": "Beta",
        "best-practice": "Best Practice"
    }
}
```

--------------------------------------------------------------------------------
/.chainlit/translations/mr.json:
--------------------------------------------------------------------------------

```json
{
    "common": {
        "actions": {
            "cancel": "\u0930\u0926\u094d\u0926 \u0915\u0930\u093e",
            "confirm": "\u092a\u0941\u0937\u094d\u091f\u0940 \u0915\u0930\u093e",
            "continue": "\u092a\u0941\u0922\u0947 \u091c\u093e",
            "goBack": "\u092e\u093e\u0917\u0947 \u091c\u093e",
            "reset": "\u0930\u0940\u0938\u0947\u091f \u0915\u0930\u093e",
            "submit": "\u0938\u092c\u092e\u093f\u091f \u0915\u0930\u093e"
        },
        "status": {
            "loading": "\u0932\u094b\u0921 \u0915\u0930\u0924 \u0906\u0939\u0947...",
            "error": {
                "default": "\u090f\u0915 \u0924\u094d\u0930\u0941\u091f\u0940 \u0906\u0932\u0940",
                "serverConnection": "\u0938\u0930\u094d\u0935\u094d\u0939\u0930\u0936\u0940 \u0915\u0928\u0947\u0915\u094d\u091f \u0939\u094b\u090a \u0936\u0915\u0932\u0947 \u0928\u093e\u0939\u0940"
            }
        }
    },
    "auth": {
        "login": {
            "title": "\u0905\u0945\u092a \u0935\u093e\u092a\u0930\u0923\u094d\u092f\u093e\u0938\u093e\u0920\u0940 \u0932\u0949\u0917\u093f\u0928 \u0915\u0930\u093e",
            "form": {
                "email": {
                    "label": "\u0908\u092e\u0947\u0932 \u092a\u0924\u094d\u0924\u093e",
                    "required": "\u0908\u092e\u0947\u0932 \u0906\u0935\u0936\u094d\u092f\u0915 \u0906\u0939\u0947"
                },
                "password": {
                    "label": "\u092a\u093e\u0938\u0935\u0930\u094d\u0921",
                    "required": "\u092a\u093e\u0938\u0935\u0930\u094d\u0921 \u0906\u0935\u0936\u094d\u092f\u0915 \u0906\u0939\u0947"
                },
                "actions": {
                    "signin": "\u0938\u093e\u0907\u0928 \u0907\u0928 \u0915\u0930\u093e"
                },
                "alternativeText": {
                    "or": "\u0915\u093f\u0902\u0935\u093e"
                }
            },
            "errors": {
                "default": "\u0938\u093e\u0907\u0928 \u0907\u0928 \u0915\u0930\u0942 \u0936\u0915\u0924 \u0928\u093e\u0939\u0940",
                "signin": "\u0935\u0947\u0917\u0933\u094d\u092f\u093e \u0916\u093e\u0924\u094d\u092f\u093e\u0928\u0947 \u0938\u093e\u0907\u0928 \u0907\u0928 \u0915\u0930\u0923\u094d\u092f\u093e\u091a\u093e \u092a\u094d\u0930\u092f\u0924\u094d\u0928 \u0915\u0930\u093e",
                "oauthSignin": "\u0935\u0947\u0917\u0933\u094d\u092f\u093e \u0916\u093e\u0924\u094d\u092f\u093e\u0928\u0947 \u0938\u093e\u0907\u0928 \u0907\u0928 \u0915\u0930\u0923\u094d\u092f\u093e\u091a\u093e \u092a\u094d\u0930\u092f\u0924\u094d\u0928 \u0915\u0930\u093e",
                "redirectUriMismatch": "\u0930\u0940\u0921\u093e\u092f\u0930\u0947\u0915\u094d\u091f URI \u0913\u0925 \u0905\u0945\u092a \u0915\u0949\u0928\u094d\u092b\u093f\u0917\u0930\u0947\u0936\u0928\u0936\u0940 \u091c\u0941\u0933\u0924 \u0928\u093e\u0939\u0940",
                "oauthCallback": "\u0935\u0947\u0917\u0933\u094d\u092f\u093e \u0916\u093e\u0924\u094d\u092f\u093e\u0928\u0947 \u0938\u093e\u0907\u0928 \u0907\u0928 \u0915\u0930\u0923\u094d\u092f\u093e\u091a\u093e \u092a\u094d\u0930\u092f\u0924\u094d\u0928 \u0915\u0930\u093e",
                "oauthCreateAccount": "\u0935\u0947\u0917\u0933\u094d\u092f\u093e \u0916\u093e\u0924\u094d\u092f\u093e\u0928\u0947 \u0938\u093e\u0907\u0928 \u0907\u0928 \u0915\u0930\u0923\u094d\u092f\u093e\u091a\u093e \u092a\u094d\u0930\u092f\u0924\u094d\u0928 \u0915\u0930\u093e",
                "emailCreateAccount": "\u0935\u0947\u0917\u0933\u094d\u092f\u093e \u0916\u093e\u0924\u094d\u092f\u093e\u0928\u0947 \u0938\u093e\u0907\u0928 \u0907\u0928 \u0915\u0930\u0923\u094d\u092f\u093e\u091a\u093e \u092a\u094d\u0930\u092f\u0924\u094d\u0928 \u0915\u0930\u093e",
                "callback": "\u0935\u0947\u0917\u0933\u094d\u092f\u093e \u0916\u093e\u0924\u094d\u092f\u093e\u0928\u0947 \u0938\u093e\u0907\u0928 \u0907\u0928 \u0915\u0930\u0923\u094d\u092f\u093e\u091a\u093e \u092a\u094d\u0930\u092f\u0924\u094d\u0928 \u0915\u0930\u093e",
                "oauthAccountNotLinked": "\u0924\u0941\u092e\u091a\u0940 \u0913\u0933\u0916 \u092a\u091f\u0935\u0923\u094d\u092f\u093e\u0938\u093e\u0920\u0940, \u092e\u0942\u0933 \u0935\u093e\u092a\u0930\u0932\u0947\u0932\u094d\u092f\u093e \u0916\u093e\u0924\u094d\u092f\u093e\u0928\u0947\u091a \u0938\u093e\u0907\u0928 \u0907\u0928 \u0915\u0930\u093e",
                "emailSignin": "\u0908\u092e\u0947\u0932 \u092a\u093e\u0920\u0935\u0942 \u0936\u0915\u0932\u0947 \u0928\u093e\u0939\u0940",
                "emailVerify": "\u0915\u0943\u092a\u092f\u093e \u0924\u0941\u092e\u091a\u093e \u0908\u092e\u0947\u0932 \u0924\u092a\u093e\u0938\u093e, \u0928\u0935\u0940\u0928 \u0908\u092e\u0947\u0932 \u092a\u093e\u0920\u0935\u0932\u093e \u0917\u0947\u0932\u093e \u0906\u0939\u0947",
                "credentialsSignin": "\u0938\u093e\u0907\u0928 \u0907\u0928 \u0905\u092f\u0936\u0938\u094d\u0935\u0940. \u0924\u0941\u092e\u094d\u0939\u0940 \u0926\u093f\u0932\u0947\u0932\u0940 \u092e\u093e\u0939\u093f\u0924\u0940 \u092f\u094b\u0917\u094d\u092f \u0906\u0939\u0947 \u0915\u093e \u0924\u0947 \u0924\u092a\u093e\u0938\u093e",
                "sessionRequired": "\u092f\u093e \u092a\u0943\u0937\u094d\u0920\u093e\u0935\u0930 \u092a\u094d\u0930\u0935\u0947\u0936 \u0915\u0930\u0923\u094d\u092f\u093e\u0938\u093e\u0920\u0940 \u0915\u0943\u092a\u092f\u093e \u0938\u093e\u0907\u0928 \u0907\u0928 \u0915\u0930\u093e"
            }
        },
        "provider": {
            "continue": "{{provider}} \u0938\u0939 \u092a\u0941\u0922\u0947 \u091c\u093e"
        }
    },
    "chat": {
        "input": {
            "placeholder": "\u0924\u0941\u092e\u091a\u093e \u0938\u0902\u0926\u0947\u0936 \u092f\u0947\u0925\u0947 \u091f\u093e\u0907\u092a \u0915\u0930\u093e...",
            "actions": {
                "send": "\u0938\u0902\u0926\u0947\u0936 \u092a\u093e\u0920\u0935\u093e",
                "stop": "\u0915\u093e\u0930\u094d\u092f \u0925\u093e\u0902\u092c\u0935\u093e",
                "attachFiles": "\u092b\u093e\u0907\u0932\u094d\u0938 \u091c\u094b\u0921\u093e"
            }
        },
        "speech": {
            "start": "\u0930\u0947\u0915\u0949\u0930\u094d\u0921\u093f\u0902\u0917 \u0938\u0941\u0930\u0942 \u0915\u0930\u093e",
            "stop": "\u0930\u0947\u0915\u0949\u0930\u094d\u0921\u093f\u0902\u0917 \u0925\u093e\u0902\u092c\u0935\u093e",
            "connecting": "\u0915\u0928\u0947\u0915\u094d\u091f \u0915\u0930\u0924 \u0906\u0939\u0947"
        },
        "fileUpload": {
            "dragDrop": "\u092b\u093e\u0907\u0932\u094d\u0938 \u092f\u0947\u0925\u0947 \u0921\u094d\u0930\u0945\u0917 \u0906\u0923\u093f \u0921\u094d\u0930\u0949\u092a \u0915\u0930\u093e",
            "browse": "\u092b\u093e\u0907\u0932\u094d\u0938 \u092c\u094d\u0930\u093e\u0909\u091d \u0915\u0930\u093e",
            "sizeLimit": "\u092e\u0930\u094d\u092f\u093e\u0926\u093e:",
            "errors": {
                "failed": "\u0905\u092a\u0932\u094b\u0921 \u0905\u092f\u0936\u0938\u094d\u0935\u0940",
                "cancelled": "\u092f\u093e\u0902\u091a\u0947 \u0905\u092a\u0932\u094b\u0921 \u0930\u0926\u094d\u0926 \u0915\u0947\u0932\u0947"
            }
        },
        "messages": {
            "status": {
                "using": "\u0935\u093e\u092a\u0930\u0924 \u0906\u0939\u0947",
                "used": "\u0935\u093e\u092a\u0930\u0932\u0947"
            },
            "actions": {
                "copy": {
                    "button": "\u0915\u094d\u0932\u093f\u092a\u092c\u094b\u0930\u094d\u0921\u0935\u0930 \u0915\u0949\u092a\u0940 \u0915\u0930\u093e",
                    "success": "\u0915\u0949\u092a\u0940 \u0915\u0947\u0932\u0947!"
                }
            },
            "feedback": {
                "positive": "\u0909\u092a\u092f\u0941\u0915\u094d\u0924",
                "negative": "\u0909\u092a\u092f\u0941\u0915\u094d\u0924 \u0928\u093e\u0939\u0940",
                "edit": "\u092b\u0940\u0921\u092c\u0945\u0915 \u0938\u0902\u092a\u093e\u0926\u093f\u0924 \u0915\u0930\u093e",
                "dialog": {
                    "title": "\u091f\u093f\u092a\u094d\u092a\u0923\u0940 \u091c\u094b\u0921\u093e",
                    "submit": "\u092b\u0940\u0921\u092c\u0945\u0915 \u0938\u092c\u092e\u093f\u091f \u0915\u0930\u093e"
                },
                "status": {
                    "updating": "\u0905\u092a\u0921\u0947\u091f \u0915\u0930\u0924 \u0906\u0939\u0947",
                    "updated": "\u092b\u0940\u0921\u092c\u0945\u0915 \u0905\u092a\u0921\u0947\u091f \u0915\u0947\u0932\u0947"
                }
            }
        },
        "history": {
            "title": "\u0936\u0947\u0935\u091f\u091a\u0947 \u0907\u0928\u092a\u0941\u091f",
            "empty": "\u0930\u093f\u0915\u093e\u092e\u0947 \u0906\u0939\u0947...",
            "show": "\u0907\u0924\u093f\u0939\u093e\u0938 \u0926\u093e\u0916\u0935\u093e"
        },
        "settings": {
            "title": "\u0938\u0947\u091f\u093f\u0902\u0917\u094d\u091c \u092a\u0945\u0928\u0932"
        },
        "watermark": "\u0938\u0939 \u092c\u0928\u0935\u0932\u0947"
    },
    "threadHistory": {
        "sidebar": {
            "title": "\u092e\u093e\u0917\u0940\u0932 \u091a\u0945\u091f\u094d\u0938",
            "filters": {
                "search": "\u0936\u094b\u0927\u093e",
                "placeholder": "Search conversations..."
            },
            "timeframes": {
                "today": "\u0906\u091c",
                "yesterday": "\u0915\u093e\u0932",
                "previous7days": "\u092e\u093e\u0917\u0940\u0932 7 \u0926\u093f\u0935\u0938",
                "previous30days": "\u092e\u093e\u0917\u0940\u0932 30 \u0926\u093f\u0935\u0938"
            },
            "empty": "\u0915\u094b\u0923\u0924\u0947\u0939\u0940 \u0925\u094d\u0930\u0947\u0921 \u0938\u093e\u092a\u0921\u0932\u0947 \u0928\u093e\u0939\u0940\u0924",
            "actions": {
                "close": "\u0938\u093e\u0907\u0921\u092c\u093e\u0930 \u092c\u0902\u0926 \u0915\u0930\u093e",
                "open": "\u0938\u093e\u0907\u0921\u092c\u093e\u0930 \u0909\u0918\u0921\u093e"
            }
        },
        "thread": {
            "untitled": "\u0936\u0940\u0930\u094d\u0937\u0915\u0935\u093f\u0930\u0939\u093f\u0924 \u0938\u0902\u092d\u093e\u0937\u0923",
            "menu": {
                "rename": "Rename",
                "delete": "Delete"
            },
            "actions": {
                "delete": {
                    "title": "\u0939\u091f\u0935\u093f\u0923\u094d\u092f\u093e\u091a\u0940 \u092a\u0941\u0937\u094d\u091f\u0940 \u0915\u0930\u093e",
                    "description": "\u0939\u0947 \u0925\u094d\u0930\u0947\u0921 \u0906\u0923\u093f \u0924\u094d\u092f\u093e\u091a\u0947 \u0938\u0902\u0926\u0947\u0936 \u0935 \u0918\u091f\u0915 \u0939\u091f\u0935\u0947\u0932. \u0939\u0940 \u0915\u094d\u0930\u093f\u092f\u093e \u092a\u0942\u0930\u094d\u0935\u0935\u0924 \u0915\u0947\u0932\u0940 \u091c\u093e\u090a \u0936\u0915\u0924 \u0928\u093e\u0939\u0940",
                    "success": "\u091a\u0945\u091f \u0939\u091f\u0935\u0932\u093e",
                    "inProgress": "\u091a\u0945\u091f \u0939\u091f\u0935\u0924 \u0906\u0939\u0947"
                },
                "rename": {
                    "title": "\u0925\u094d\u0930\u0947\u0921\u091a\u0947 \u0928\u093e\u0935 \u092c\u0926\u0932\u093e",
                    "description": "\u092f\u093e \u0925\u094d\u0930\u0947\u0921\u0938\u093e\u0920\u0940 \u0928\u0935\u0940\u0928 \u0928\u093e\u0935 \u092a\u094d\u0930\u0935\u093f\u0937\u094d\u091f \u0915\u0930\u093e",
                    "form": {
                        "name": {
                            "label": "\u0928\u093e\u0935",
                            "placeholder": "\u0928\u0935\u0940\u0928 \u0928\u093e\u0935 \u092a\u094d\u0930\u0935\u093f\u0937\u094d\u091f \u0915\u0930\u093e"
                        }
                    },
                    "success": "\u0925\u094d\u0930\u0947\u0921\u091a\u0947 \u0928\u093e\u0935 \u092c\u0926\u0932\u0932\u0947!",
                    "inProgress": "\u0925\u094d\u0930\u0947\u0921\u091a\u0947 \u0928\u093e\u0935 \u092c\u0926\u0932\u0924 \u0906\u0939\u0947"
                }
            }
        }
    },
    "navigation": {
        "header": {
            "chat": "\u091a\u0945\u091f",
            "readme": "\u0935\u093e\u091a\u093e",
            "theme": {
                "light": "Light Theme",
                "dark": "Dark Theme",
                "system": "Follow System"
            }
        },
        "newChat": {
            "button": "\u0928\u0935\u0940\u0928 \u091a\u0945\u091f",
            "dialog": {
                "title": "\u0928\u0935\u0940\u0928 \u091a\u0945\u091f \u0924\u092f\u093e\u0930 \u0915\u0930\u093e",
                "description": "\u0939\u0947 \u0924\u0941\u092e\u091a\u093e \u0938\u0927\u094d\u092f\u093e\u091a\u093e \u091a\u0945\u091f \u0907\u0924\u093f\u0939\u093e\u0938 \u0938\u093e\u092b \u0915\u0930\u0947\u0932. \u0924\u0941\u092e\u094d\u0939\u093e\u0932\u093e \u0916\u093e\u0924\u094d\u0930\u0940 \u0906\u0939\u0947 \u0915\u0940 \u0924\u0941\u092e\u094d\u0939\u0940 \u092a\u0941\u0922\u0947 \u091c\u093e\u090a \u0907\u091a\u094d\u091b\u093f\u0924\u093e?",
                "tooltip": "\u0928\u0935\u0940\u0928 \u091a\u0945\u091f"
            }
        },
        "user": {
            "menu": {
                "settings": "\u0938\u0947\u091f\u093f\u0902\u0917\u094d\u091c",
                "settingsKey": "S",
                "apiKeys": "API \u0915\u0940\u091c",
                "logout": "\u0932\u0949\u0917\u0906\u0909\u091f"
            }
        }
    },
    "apiKeys": {
        "title": "\u0906\u0935\u0936\u094d\u092f\u0915 API \u0915\u0940\u091c",
        "description": "\u0939\u0947 \u0905\u0945\u092a \u0935\u093e\u092a\u0930\u0923\u094d\u092f\u093e\u0938\u093e\u0920\u0940 \u0916\u093e\u0932\u0940\u0932 API \u0915\u0940\u091c \u0906\u0935\u0936\u094d\u092f\u0915 \u0906\u0939\u0947\u0924. \u0915\u0940\u091c \u0924\u0941\u092e\u091a\u094d\u092f\u093e \u0921\u093f\u0935\u094d\u0939\u093e\u0907\u0938\u091a\u094d\u092f\u093e \u0932\u094b\u0915\u0932 \u0938\u094d\u091f\u094b\u0930\u0947\u091c\u092e\u0927\u094d\u092f\u0947 \u0938\u093e\u0920\u0935\u0932\u094d\u092f\u093e \u091c\u093e\u0924\u093e\u0924.",
        "success": {
            "saved": "\u092f\u0936\u0938\u094d\u0935\u0940\u0930\u093f\u0924\u094d\u092f\u093e \u091c\u0924\u0928 \u0915\u0947\u0932\u0947"
        }
    },
    "alerts": {
        "info": "Info",
        "note": "Note",
        "tip": "Tip",
        "important": "Important",
        "warning": "Warning",
        "caution": "Caution",
        "debug": "Debug",
        "example": "Example",
        "success": "Success",
        "help": "Help",
        "idea": "Idea",
        "pending": "Pending",
        "security": "Security",
        "beta": "Beta",
        "best-practice": "Best Practice"
    }
}
```

--------------------------------------------------------------------------------
/.chainlit/translations/hi.json:
--------------------------------------------------------------------------------

```json
{
    "common": {
        "actions": {
            "cancel": "\u0930\u0926\u094d\u0926 \u0915\u0930\u0947\u0902",
            "confirm": "\u092a\u0941\u0937\u094d\u091f\u093f \u0915\u0930\u0947\u0902",
            "continue": "\u091c\u093e\u0930\u0940 \u0930\u0916\u0947\u0902",
            "goBack": "\u0935\u093e\u092a\u0938 \u091c\u093e\u090f\u0902",
            "reset": "\u0930\u0940\u0938\u0947\u091f \u0915\u0930\u0947\u0902",
            "submit": "\u091c\u092e\u093e \u0915\u0930\u0947\u0902"
        },
        "status": {
            "loading": "\u0932\u094b\u0921 \u0939\u094b \u0930\u0939\u093e \u0939\u0948...",
            "error": {
                "default": "\u090f\u0915 \u0924\u094d\u0930\u0941\u091f\u093f \u0939\u0941\u0908",
                "serverConnection": "\u0938\u0930\u094d\u0935\u0930 \u0938\u0947 \u0938\u0902\u092a\u0930\u094d\u0915 \u0928\u0939\u0940\u0902 \u0939\u094b \u092a\u093e \u0930\u0939\u093e"
            }
        }
    },
    "auth": {
        "login": {
            "title": "\u0910\u092a \u0915\u093e \u0909\u092a\u092f\u094b\u0917 \u0915\u0930\u0928\u0947 \u0915\u0947 \u0932\u093f\u090f \u0932\u0949\u0917\u093f\u0928 \u0915\u0930\u0947\u0902",
            "form": {
                "email": {
                    "label": "\u0908\u092e\u0947\u0932 \u092a\u0924\u093e",
                    "required": "\u0908\u092e\u0947\u0932 \u090f\u0915 \u0906\u0935\u0936\u094d\u092f\u0915 \u092b\u093c\u0940\u0932\u094d\u0921 \u0939\u0948"
                },
                "password": {
                    "label": "\u092a\u093e\u0938\u0935\u0930\u094d\u0921",
                    "required": "\u092a\u093e\u0938\u0935\u0930\u094d\u0921 \u090f\u0915 \u0906\u0935\u0936\u094d\u092f\u0915 \u092b\u093c\u0940\u0932\u094d\u0921 \u0939\u0948"
                },
                "actions": {
                    "signin": "\u0938\u093e\u0907\u0928 \u0907\u0928 \u0915\u0930\u0947\u0902"
                },
                "alternativeText": {
                    "or": "\u092f\u093e"
                }
            },
            "errors": {
                "default": "\u0938\u093e\u0907\u0928 \u0907\u0928 \u0915\u0930\u0928\u0947 \u092e\u0947\u0902 \u0905\u0938\u092e\u0930\u094d\u0925",
                "signin": "\u0915\u093f\u0938\u0940 \u0926\u0942\u0938\u0930\u0947 \u0916\u093e\u0924\u0947 \u0938\u0947 \u0938\u093e\u0907\u0928 \u0907\u0928 \u0915\u0930\u0928\u0947 \u0915\u093e \u092a\u094d\u0930\u092f\u093e\u0938 \u0915\u0930\u0947\u0902",
                "oauthSignin": "\u0915\u093f\u0938\u0940 \u0926\u0942\u0938\u0930\u0947 \u0916\u093e\u0924\u0947 \u0938\u0947 \u0938\u093e\u0907\u0928 \u0907\u0928 \u0915\u0930\u0928\u0947 \u0915\u093e \u092a\u094d\u0930\u092f\u093e\u0938 \u0915\u0930\u0947\u0902",
                "redirectUriMismatch": "\u0930\u0940\u0921\u093e\u092f\u0930\u0947\u0915\u094d\u091f URI oauth \u0910\u092a \u0915\u0949\u0928\u094d\u092b\u093c\u093f\u0917\u0930\u0947\u0936\u0928 \u0938\u0947 \u092e\u0947\u0932 \u0928\u0939\u0940\u0902 \u0916\u093e \u0930\u0939\u093e",
                "oauthCallback": "\u0915\u093f\u0938\u0940 \u0926\u0942\u0938\u0930\u0947 \u0916\u093e\u0924\u0947 \u0938\u0947 \u0938\u093e\u0907\u0928 \u0907\u0928 \u0915\u0930\u0928\u0947 \u0915\u093e \u092a\u094d\u0930\u092f\u093e\u0938 \u0915\u0930\u0947\u0902",
                "oauthCreateAccount": "\u0915\u093f\u0938\u0940 \u0926\u0942\u0938\u0930\u0947 \u0916\u093e\u0924\u0947 \u0938\u0947 \u0938\u093e\u0907\u0928 \u0907\u0928 \u0915\u0930\u0928\u0947 \u0915\u093e \u092a\u094d\u0930\u092f\u093e\u0938 \u0915\u0930\u0947\u0902",
                "emailCreateAccount": "\u0915\u093f\u0938\u0940 \u0926\u0942\u0938\u0930\u0947 \u0916\u093e\u0924\u0947 \u0938\u0947 \u0938\u093e\u0907\u0928 \u0907\u0928 \u0915\u0930\u0928\u0947 \u0915\u093e \u092a\u094d\u0930\u092f\u093e\u0938 \u0915\u0930\u0947\u0902",
                "callback": "\u0915\u093f\u0938\u0940 \u0926\u0942\u0938\u0930\u0947 \u0916\u093e\u0924\u0947 \u0938\u0947 \u0938\u093e\u0907\u0928 \u0907\u0928 \u0915\u0930\u0928\u0947 \u0915\u093e \u092a\u094d\u0930\u092f\u093e\u0938 \u0915\u0930\u0947\u0902",
                "oauthAccountNotLinked": "\u0905\u092a\u0928\u0940 \u092a\u0939\u091a\u093e\u0928 \u0915\u0940 \u092a\u0941\u0937\u094d\u091f\u093f \u0915\u0930\u0928\u0947 \u0915\u0947 \u0932\u093f\u090f, \u0909\u0938\u0940 \u0916\u093e\u0924\u0947 \u0938\u0947 \u0938\u093e\u0907\u0928 \u0907\u0928 \u0915\u0930\u0947\u0902 \u091c\u093f\u0938\u0915\u093e \u0909\u092a\u092f\u094b\u0917 \u0906\u092a\u0928\u0947 \u092e\u0942\u0932 \u0930\u0942\u092a \u0938\u0947 \u0915\u093f\u092f\u093e \u0925\u093e",
                "emailSignin": "\u0908\u092e\u0947\u0932 \u0928\u0939\u0940\u0902 \u092d\u0947\u091c\u093e \u091c\u093e \u0938\u0915\u093e",
                "emailVerify": "\u0915\u0943\u092a\u092f\u093e \u0905\u092a\u0928\u093e \u0908\u092e\u0947\u0932 \u0938\u0924\u094d\u092f\u093e\u092a\u093f\u0924 \u0915\u0930\u0947\u0902, \u090f\u0915 \u0928\u092f\u093e \u0908\u092e\u0947\u0932 \u092d\u0947\u091c\u093e \u0917\u092f\u093e \u0939\u0948",
                "credentialsSignin": "\u0938\u093e\u0907\u0928 \u0907\u0928 \u0935\u093f\u092b\u0932\u0964 \u0906\u092a\u0915\u0947 \u0926\u094d\u0935\u093e\u0930\u093e \u092a\u094d\u0930\u0926\u093e\u0928 \u0915\u093f\u090f \u0917\u090f \u0935\u093f\u0935\u0930\u0923 \u0915\u0940 \u091c\u093e\u0902\u091a \u0915\u0930\u0947\u0902",
                "sessionRequired": "\u0907\u0938 \u092a\u0943\u0937\u094d\u0920 \u0924\u0915 \u092a\u0939\u0941\u0902\u091a\u0928\u0947 \u0915\u0947 \u0932\u093f\u090f \u0915\u0943\u092a\u092f\u093e \u0938\u093e\u0907\u0928 \u0907\u0928 \u0915\u0930\u0947\u0902"
            }
        },
        "provider": {
            "continue": "{{provider}} \u0915\u0947 \u0938\u093e\u0925 \u091c\u093e\u0930\u0940 \u0930\u0916\u0947\u0902"
        }
    },
    "chat": {
        "input": {
            "placeholder": "\u0905\u092a\u0928\u093e \u0938\u0902\u0926\u0947\u0936 \u092f\u0939\u093e\u0902 \u091f\u093e\u0907\u092a \u0915\u0930\u0947\u0902...",
            "actions": {
                "send": "\u0938\u0902\u0926\u0947\u0936 \u092d\u0947\u091c\u0947\u0902",
                "stop": "\u0915\u093e\u0930\u094d\u092f \u0930\u094b\u0915\u0947\u0902",
                "attachFiles": "\u092b\u093c\u093e\u0907\u0932\u0947\u0902 \u0938\u0902\u0932\u0917\u094d\u0928 \u0915\u0930\u0947\u0902"
            }
        },
        "speech": {
            "start": "\u0930\u093f\u0915\u0949\u0930\u094d\u0921\u093f\u0902\u0917 \u0936\u0941\u0930\u0942 \u0915\u0930\u0947\u0902",
            "stop": "\u0930\u093f\u0915\u0949\u0930\u094d\u0921\u093f\u0902\u0917 \u0930\u094b\u0915\u0947\u0902",
            "connecting": "\u0915\u0928\u0947\u0915\u094d\u091f \u0939\u094b \u0930\u0939\u093e \u0939\u0948"
        },
        "fileUpload": {
            "dragDrop": "\u092b\u093c\u093e\u0907\u0932\u094b\u0902 \u0915\u094b \u092f\u0939\u093e\u0902 \u0916\u0940\u0902\u091a\u0947\u0902 \u0914\u0930 \u091b\u094b\u0921\u093c\u0947\u0902",
            "browse": "\u092b\u093c\u093e\u0907\u0932\u0947\u0902 \u092c\u094d\u0930\u093e\u0909\u091c\u093c \u0915\u0930\u0947\u0902",
            "sizeLimit": "\u0938\u0940\u092e\u093e:",
            "errors": {
                "failed": "\u0905\u092a\u0932\u094b\u0921 \u0915\u0930\u0928\u0947 \u092e\u0947\u0902 \u0935\u093f\u092b\u0932",
                "cancelled": "\u0915\u093e \u0905\u092a\u0932\u094b\u0921 \u0930\u0926\u094d\u0926 \u0915\u093f\u092f\u093e \u0917\u092f\u093e"
            }
        },
        "messages": {
            "status": {
                "using": "\u0909\u092a\u092f\u094b\u0917 \u0915\u0930 \u0930\u0939\u0947 \u0939\u0948\u0902",
                "used": "\u0909\u092a\u092f\u094b\u0917 \u0915\u093f\u092f\u093e"
            },
            "actions": {
                "copy": {
                    "button": "\u0915\u094d\u0932\u093f\u092a\u092c\u094b\u0930\u094d\u0921 \u092a\u0930 \u0915\u0949\u092a\u0940 \u0915\u0930\u0947\u0902",
                    "success": "\u0915\u0949\u092a\u0940 \u0915\u093f\u092f\u093e \u0917\u092f\u093e!"
                }
            },
            "feedback": {
                "positive": "\u0938\u0939\u093e\u092f\u0915",
                "negative": "\u0938\u0939\u093e\u092f\u0915 \u0928\u0939\u0940\u0902",
                "edit": "\u092a\u094d\u0930\u0924\u093f\u0915\u094d\u0930\u093f\u092f\u093e \u0938\u0902\u092a\u093e\u0926\u093f\u0924 \u0915\u0930\u0947\u0902",
                "dialog": {
                    "title": "\u091f\u093f\u092a\u094d\u092a\u0923\u0940 \u091c\u094b\u0921\u093c\u0947\u0902",
                    "submit": "\u092a\u094d\u0930\u0924\u093f\u0915\u094d\u0930\u093f\u092f\u093e \u091c\u092e\u093e \u0915\u0930\u0947\u0902"
                },
                "status": {
                    "updating": "\u0905\u092a\u0921\u0947\u091f \u0939\u094b \u0930\u0939\u093e \u0939\u0948",
                    "updated": "\u092a\u094d\u0930\u0924\u093f\u0915\u094d\u0930\u093f\u092f\u093e \u0905\u092a\u0921\u0947\u091f \u0915\u0940 \u0917\u0908"
                }
            }
        },
        "history": {
            "title": "\u092a\u093f\u091b\u0932\u0947 \u0907\u0928\u092a\u0941\u091f",
            "empty": "\u0915\u0941\u091b \u092d\u0940 \u0928\u0939\u0940\u0902 \u0939\u0948...",
            "show": "\u0907\u0924\u093f\u0939\u093e\u0938 \u0926\u093f\u0916\u093e\u090f\u0902"
        },
        "settings": {
            "title": "\u0938\u0947\u091f\u093f\u0902\u0917\u094d\u0938 \u092a\u0948\u0928\u0932"
        },
        "watermark": "\u0915\u0947 \u0938\u093e\u0925 \u092c\u0928\u093e\u092f\u093e \u0917\u092f\u093e"
    },
    "threadHistory": {
        "sidebar": {
            "title": "\u092a\u093f\u091b\u0932\u0940 \u091a\u0948\u091f",
            "filters": {
                "search": "\u0916\u094b\u091c\u0947\u0902",
                "placeholder": "Search conversations..."
            },
            "timeframes": {
                "today": "\u0906\u091c",
                "yesterday": "\u0915\u0932",
                "previous7days": "\u092a\u093f\u091b\u0932\u0947 7 \u0926\u093f\u0928",
                "previous30days": "\u092a\u093f\u091b\u0932\u0947 30 \u0926\u093f\u0928"
            },
            "empty": "\u0915\u094b\u0908 \u0925\u094d\u0930\u0947\u0921 \u0928\u0939\u0940\u0902 \u092e\u093f\u0932\u093e",
            "actions": {
                "close": "\u0938\u093e\u0907\u0921\u092c\u093e\u0930 \u092c\u0902\u0926 \u0915\u0930\u0947\u0902",
                "open": "\u0938\u093e\u0907\u0921\u092c\u093e\u0930 \u0916\u094b\u0932\u0947\u0902"
            }
        },
        "thread": {
            "untitled": "\u0936\u0940\u0930\u094d\u0937\u0915\u0939\u0940\u0928 \u0935\u093e\u0930\u094d\u0924\u093e\u0932\u093e\u092a",
            "menu": {
                "rename": "Rename",
                "delete": "Delete"
            },
            "actions": {
                "delete": {
                    "title": "\u0939\u091f\u093e\u0928\u0947 \u0915\u0940 \u092a\u0941\u0937\u094d\u091f\u093f \u0915\u0930\u0947\u0902",
                    "description": "\u092f\u0939 \u0925\u094d\u0930\u0947\u0921 \u0914\u0930 \u0907\u0938\u0915\u0947 \u0938\u0902\u0926\u0947\u0936\u094b\u0902 \u0914\u0930 \u0924\u0924\u094d\u0935\u094b\u0902 \u0915\u094b \u0939\u091f\u093e \u0926\u0947\u0917\u093e\u0964 \u092f\u0939 \u0915\u094d\u0930\u093f\u092f\u093e \u0935\u093e\u092a\u0938 \u0928\u0939\u0940\u0902 \u0915\u0940 \u091c\u093e \u0938\u0915\u0924\u0940",
                    "success": "\u091a\u0948\u091f \u0939\u091f\u093e \u0926\u0940 \u0917\u0908",
                    "inProgress": "\u091a\u0948\u091f \u0939\u091f\u093e\u0908 \u091c\u093e \u0930\u0939\u0940 \u0939\u0948"
                },
                "rename": {
                    "title": "\u0925\u094d\u0930\u0947\u0921 \u0915\u093e \u0928\u093e\u092e \u092c\u0926\u0932\u0947\u0902",
                    "description": "\u0907\u0938 \u0925\u094d\u0930\u0947\u0921 \u0915\u0947 \u0932\u093f\u090f \u090f\u0915 \u0928\u092f\u093e \u0928\u093e\u092e \u0926\u0930\u094d\u091c \u0915\u0930\u0947\u0902",
                    "form": {
                        "name": {
                            "label": "\u0928\u093e\u092e",
                            "placeholder": "\u0928\u092f\u093e \u0928\u093e\u092e \u0926\u0930\u094d\u091c \u0915\u0930\u0947\u0902"
                        }
                    },
                    "success": "\u0925\u094d\u0930\u0947\u0921 \u0915\u093e \u0928\u093e\u092e \u092c\u0926\u0932 \u0926\u093f\u092f\u093e \u0917\u092f\u093e!",
                    "inProgress": "\u0925\u094d\u0930\u0947\u0921 \u0915\u093e \u0928\u093e\u092e \u092c\u0926\u0932\u093e \u091c\u093e \u0930\u0939\u093e \u0939\u0948"
                }
            }
        }
    },
    "navigation": {
        "header": {
            "chat": "\u091a\u0948\u091f",
            "readme": "\u0930\u0940\u0921\u092e\u0940",
            "theme": {
                "light": "Light Theme",
                "dark": "Dark Theme",
                "system": "Follow System"
            }
        },
        "newChat": {
            "button": "\u0928\u0908 \u091a\u0948\u091f",
            "dialog": {
                "title": "\u0928\u0908 \u091a\u0948\u091f \u092c\u0928\u093e\u090f\u0902",
                "description": "\u092f\u0939 \u0906\u092a\u0915\u093e \u0935\u0930\u094d\u0924\u092e\u093e\u0928 \u091a\u0948\u091f \u0907\u0924\u093f\u0939\u093e\u0938 \u0938\u093e\u092b\u093c \u0915\u0930 \u0926\u0947\u0917\u093e\u0964 \u0915\u094d\u092f\u093e \u0906\u092a \u091c\u093e\u0930\u0940 \u0930\u0916\u0928\u093e \u091a\u093e\u0939\u0924\u0947 \u0939\u0948\u0902?",
                "tooltip": "\u0928\u0908 \u091a\u0948\u091f"
            }
        },
        "user": {
            "menu": {
                "settings": "\u0938\u0947\u091f\u093f\u0902\u0917\u094d\u0938",
                "settingsKey": "S",
                "apiKeys": "API \u0915\u0941\u0902\u091c\u093f\u092f\u093e\u0902",
                "logout": "\u0932\u0949\u0917\u0906\u0909\u091f"
            }
        }
    },
    "apiKeys": {
        "title": "\u0906\u0935\u0936\u094d\u092f\u0915 API \u0915\u0941\u0902\u091c\u093f\u092f\u093e\u0902",
        "description": "\u0907\u0938 \u0910\u092a \u0915\u093e \u0909\u092a\u092f\u094b\u0917 \u0915\u0930\u0928\u0947 \u0915\u0947 \u0932\u093f\u090f, \u0928\u093f\u092e\u094d\u0928\u0932\u093f\u0916\u093f\u0924 API \u0915\u0941\u0902\u091c\u093f\u092f\u093e\u0902 \u0906\u0935\u0936\u094d\u092f\u0915 \u0939\u0948\u0902\u0964 \u0915\u0941\u0902\u091c\u093f\u092f\u093e\u0902 \u0906\u092a\u0915\u0947 \u0921\u093f\u0935\u093e\u0907\u0938 \u0915\u0947 \u0938\u094d\u0925\u093e\u0928\u0940\u092f \u0938\u0902\u0917\u094d\u0930\u0939\u0923 \u092e\u0947\u0902 \u0938\u0902\u0917\u094d\u0930\u0939\u0940\u0924 \u0915\u0940 \u091c\u093e\u0924\u0940 \u0939\u0948\u0902\u0964",
        "success": {
            "saved": "\u0938\u092b\u0932\u0924\u093e\u092a\u0942\u0930\u094d\u0935\u0915 \u0938\u0939\u0947\u091c\u093e \u0917\u092f\u093e"
        }
    },
    "alerts": {
        "info": "Info",
        "note": "Note",
        "tip": "Tip",
        "important": "Important",
        "warning": "Warning",
        "caution": "Caution",
        "debug": "Debug",
        "example": "Example",
        "success": "Success",
        "help": "Help",
        "idea": "Idea",
        "pending": "Pending",
        "security": "Security",
        "beta": "Beta",
        "best-practice": "Best Practice"
    }
}
```

