llm-to-cli 0.1.0__tar.gz

llm_to_cli-0.1.0/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.1
+Name: llm-to-cli
+Version: 0.1.0
+Summary: 
+Author: tikendraw
+Author-email: tikendraksahu1029@gmail.com
+Requires-Python: >=3.11,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: click (>=8.1.7,<9.0.0)
+Requires-Dist: litellm (>=1.52.16,<2.0.0)
+Requires-Dist: rich (>=13.9.4,<14.0.0)
+Description-Content-Type: text/markdown
+
+# LLM-cli
+A lightweight Command Line Interface (CLI) for interacting with Large Language Models (LLMs) using LiteLLM.
+
+
+## 💡 Why This Project?
+Sometimes network constraints or data limitations make it difficult to access large language models via web interfaces. This CLI provides a lightweight, flexible solution for LLM interactions directly from the terminal.
+
+
+## 🚀 Features
+
+- **Simple CLI Interface**: Easily chat with different LLMs from your terminal
+- **Multiple Chat Modes**:
+  - Direct single-message chat
+  - Interactive chat UI with markdown rendering
+  - Image support for vision-capable models
+- **Flexible Configuration**: Customize model, temperature, and system prompts
+- **Easy Configuration Management**: Update settings with a simple command
+
+## 🔧 Prerequisites
+
+- Api keys to the llms
+
+## 💾 Installation
+
+1. Via Pip
+```bash
+pip install llm-cli
+```
+2. From Repo
+```bash
+# Clone the repository
+git clone https://github.com/tikendraw/llm-cli.git
+cd llm-cli
+
+# Install 
+pip install .
+```
+
+## 🖥️ Usage
+
+### Basic Chat
+
+Send a single message to an LLM:
+
+```bash
+llm-cli chat "Hello, how are you?"
+```
+
+### Interactive Chat UI
+
+Start an interactive chat session:
+
+```bash
+llm-cli chatui
+```
+
+### Image Support
+
+Chat with an image:
+
+```bash
+llm-cli chatui2 --model openai/gpt-4o-somthing
+```
+
+### Configuration
+
+View current configuration:
+```bash
+llm-cli config
+```
+
+Update configuration:
+```bash
+llm-cli config model "anthropic/claude-3-haiku"
+llm-cli config temperature 0.7
+```
+
+## 🛠️ Commands
+
+- `chat`: Send a single message
+- `chatui`: Interactive chat with markdown rendering
+- `chatui2`: Interactive chat with image support
+- `config`: Manage CLI configuration
+
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+

llm_to_cli-0.1.0/README.md

@@ -0,0 +1,89 @@
+# LLM-cli
+A lightweight Command Line Interface (CLI) for interacting with Large Language Models (LLMs) using LiteLLM.
+
+
+## 💡 Why This Project?
+Sometimes network constraints or data limitations make it difficult to access large language models via web interfaces. This CLI provides a lightweight, flexible solution for LLM interactions directly from the terminal.
+
+
+## 🚀 Features
+
+- **Simple CLI Interface**: Easily chat with different LLMs from your terminal
+- **Multiple Chat Modes**:
+  - Direct single-message chat
+  - Interactive chat UI with markdown rendering
+  - Image support for vision-capable models
+- **Flexible Configuration**: Customize model, temperature, and system prompts
+- **Easy Configuration Management**: Update settings with a simple command
+
+## 🔧 Prerequisites
+
+- Api keys to the llms
+
+## 💾 Installation
+
+1. Via Pip
+```bash
+pip install llm-cli
+```
+2. From Repo
+```bash
+# Clone the repository
+git clone https://github.com/tikendraw/llm-cli.git
+cd llm-cli
+
+# Install 
+pip install .
+```
+
+## 🖥️ Usage
+
+### Basic Chat
+
+Send a single message to an LLM:
+
+```bash
+llm-cli chat "Hello, how are you?"
+```
+
+### Interactive Chat UI
+
+Start an interactive chat session:
+
+```bash
+llm-cli chatui
+```
+
+### Image Support
+
+Chat with an image:
+
+```bash
+llm-cli chatui2 --model openai/gpt-4o-somthing
+```
+
+### Configuration
+
+View current configuration:
+```bash
+llm-cli config
+```
+
+Update configuration:
+```bash
+llm-cli config model "anthropic/claude-3-haiku"
+llm-cli config temperature 0.7
+```
+
+## 🛠️ Commands
+
+- `chat`: Send a single message
+- `chatui`: Interactive chat with markdown rendering
+- `chatui2`: Interactive chat with image support
+- `config`: Manage CLI configuration
+
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+

llm_to_cli-0.1.0/cli/main.py

@@ -0,0 +1,259 @@
+import os
+from dataclasses import asdict, fields
+
+import click
+from rich.console import Console
+from rich.markdown import Markdown
+
+from cli.utils import delete_chat_session, get_chat_history, init_db, save_chat_history
+from core.chat import chat as cc
+from core.chat import is_vision_llm, parse_image, unparse_image
+from core.config import ChatConfig, load_config, save_config
+from core.prompt import system_prompt_cot
+
+sys_p = system_prompt_cot
+console = Console()
+configg = load_config()
+
+init_db()
+
+
+@click.group
+def cli():
+    """ llm-cli application """
+    pass
+
+
+
+@cli.command()
+@click.argument('message', type=str)
+@click.option('--system_prompt', '-s', default=sys_p, type=str, help='system prompt to the llm')
+@click.option('--model', '-m', default=configg.model, help='model name e.g.: provider/model_name')
+@click.option('--temperature', '-t', default=configg.temperature, help='float value between 0 and 1, lower value means more deterministic, higher value means more creative')
+@click.option('--image', type=click.Path(exists=True), default=None, help='file path or url to an image')
+@click.option('--no_system_prompt', is_flag=True, help='disable system prompt')
+@click.option('--skip_vision_check', is_flag=True, help='skip vision check')
+def chat(model, message, temperature, system_prompt, image, no_system_prompt, skip_vision_check):
+    messages = []
+    if system_prompt and not no_system_prompt:
+        messages.append({"role": "system", "content": system_prompt})
+        
+    if image:
+        if is_vision_llm(model) or skip_vision_check:
+            content = parse_image(image=image, message=message)
+            messages.append({'role' : 'user', 'content' : content})
+        else:
+            console.print(f'[red]{model} is not a vision model(according to litellm).[/red]')
+            return
+    else:            
+        messages.append({"role": "user", "content": message})
+    
+    # print('model: ', model)
+    # print(f'gave this: {messages}')
+    
+    response = cc(model=model, messages=messages, temperature=temperature)
+    click.secho(response.choices[0].message['content'], fg='green')
+    
+
+def print_markdown(message: str) -> None:
+    """Render a message as Markdown or plain text."""
+    try:
+        md = Markdown(message)
+        console.print(md)
+    except Exception:
+        console.print(message)
+    console.print("\n")
+
+
+def show_messages(messages: list[dict], console: Console, show_system_prompt: bool = False) -> None:
+    """Display chat messages in the console."""
+    for message in messages:
+        role = message['role']
+        
+        if role == 'system' and not show_system_prompt:
+            continue
+
+        content = message['content']
+        image_path = None
+        if isinstance(content, list):
+            content, image_path = unparse_image(content)
+
+
+
+        if role == 'user':
+            console.print("[blue]You 👦:[/blue]")
+        elif role == 'assistant':
+            console.print("[green]LLM 🤖:[/green]")
+        elif role == 'system':
+            console.print("[cyan]System 🤖:[/cyan]")
+        else:
+            console.print("[yellow]Unknown Role:[/yellow]")
+
+        if image_path:
+            console.print(f'[yellow]Image is saved here: file:///{image_path}[/yellow]')
+        print_markdown(content)
+
+
+@cli.command()
+@click.option('--system_prompt', '-s', default=sys_p, type=str, help='System prompt to the LLM')
+@click.option('--model', '-m', default=configg.model, help='Model name, e.g., provider/model_name')
+@click.option('--temperature', '-t', default=configg.temperature, help=f'Temperature for the LLM, defaults to {configg.temperature}')
+@click.option('--no_system_prompt', is_flag=True, help='Disable system prompt')
+@click.option('--skip_vision_check', is_flag=True, help="Skip vision model check, (useful when litellm doesn't see the model as vision model)")
+@click.option('--session_id', type=str, default=None, help='Session ID to continue')
+@click.option('--title', '-t', default="Untitled Session", help='Title/description for the session')
+def chatui(system_prompt, model, temperature, no_system_prompt, skip_vision_check, session_id, title):
+    """Interactive chat interface with markdown rendering and image support."""
+    console.print("[cyan]Welcome to ChatUI![/cyan]")
+    console.print("[cyan]Type '/exit' to quit, '/clear' to reset conversation, '/help' for help, or '/image <path>' to add an image.[/cyan]\n")
+
+    messages = []
+    pending_image = None
+
+    if system_prompt and not no_system_prompt:
+        messages.append({"role": "system", "content": system_prompt})
+
+    if session_id:
+            session = get_chat_history(session_id)
+            if session:
+                session_id, start_time, session_title, chat_history = session
+                messages = chat_history
+                console.print(f"[green]Continuing session '{session_title}' (ID: {session_id}) from {start_time}[/green]")
+            else:
+                console.print(f"[red]Session ID {session_id} not found. Starting a new session.[/red]")
+    else:
+        session_id = None
+
+
+    show_messages(messages, console)
+
+    while True:
+        user_input = click.prompt(click.style("You 👦", fg="blue"), default="", show_default=False).strip()
+
+        if user_input.lower() in {"/exit", "/quit"}:
+            session_id = save_chat_history(messages, session_id=session_id, title=title)
+            console.print(f"[cyan]Session saved with ID {session_id}. Goodbye![/cyan]")
+            break
+        elif user_input.lower() == "/clear":
+            messages = [{"role": "system", "content": system_prompt}] if not no_system_prompt else []
+            pending_image = None
+            console.print("[yellow]Conversation history cleared.[/yellow]\n")
+            continue
+        elif user_input.lower() == "/help":
+            console.print("[yellow]Available commands:[/yellow]\n"
+                          "[bold yellow]/help[/bold yellow] - Show help message\n"
+                          "[bold yellow]/exit or /quit[/bold yellow] - Exit the chat\n"
+                          "[bold yellow]/clear[/bold yellow] - Reset conversation history\n"
+                          "[bold yellow]/image <path>[/bold yellow] - Add an image to the conversation\n")
+            continue
+
+        if user_input.startswith("/image"):
+            try:
+                _, image_path = user_input.split(maxsplit=1)
+                if not os.path.exists(image_path):
+                    console.print(f"[red]Image file '{image_path}' not found![/red]")
+                    continue
+                if is_vision_llm(model) or skip_vision_check:
+                    pending_image = image_path
+                    console.print(f"[green]Image '{image_path}' added. Enter a message with the image.[/green]")
+                else:
+                    console.print(f"[red]{model} is not a vision model.[/red]")
+                    pending_image = None
+            except ValueError:
+                console.print("[red]Please provide a valid image path using '/image <path>'.[/red]")
+            continue
+
+        if pending_image:
+            content = parse_image(image=pending_image, message=user_input)
+            messages.append({"role": "user", "content": content})
+            pending_image = None
+        else:
+            messages.append({"role": "user", "content": user_input})
+
+        response = cc(model=model, messages=messages, temperature=temperature)
+        llm_message = response.choices[0].message["content"]
+        messages.append({"role": "assistant", "content": llm_message})
+
+        show_messages([{"role": "assistant", "content": llm_message}], console)
+
+
+
+
+@cli.command()
+@click.option('--delete_session', type=str, required=False, default=None, help='Session ID to delete, or "all" to delete all sessions.')
+def history(delete_session):
+    """List all saved chat sessions."""
+    
+    if delete_session:
+        delete_chat_session(delete_session)
+        console.print(f"[green]Session {delete_session} deleted.[/green]")
+        return
+        
+    sessions = get_chat_history()
+    console.print("[cyan]Chat History:[/cyan]\n")
+    if sessions:
+        for session in sessions:
+            session_id, start_time, title, length = session
+            console.print(f"[yellow]Session ID:[/yellow] {session_id}\n"
+                          f"[yellow]Start Time:[/yellow] {start_time}\n"
+                          f"[yellow]Title:[/yellow] {title}\n"
+                          f"[yellow]Length:[/yellow] {length} turns\n")
+    else:
+        console.print("[red]No chat history found.[/red]")
+        
+        
+@cli.command()
+@click.argument('key', required=False, default=None)
+@click.argument('value', required=False, default=None)
+def config(key: str, value: str):
+    """
+    Configure chat settings.
+    Without arguments, displays the current configuration.
+    To update, provide a key and a value.
+    """
+    current_config = load_config()
+    config_dict = asdict(current_config)
+
+    if not key:
+        # Show current configuration if no arguments are provided
+        click.secho("Current configuration:", fg='cyan')
+        for field_name, field_value in config_dict.items():
+            click.secho(f"  {field_name}: {field_value}", fg='yellow')
+        return
+
+    # Validate the provided key
+    if key not in config_dict:
+        click.secho(f"Invalid configuration key: {key}", fg='red')
+        click.secho("Valid keys are:", fg='cyan')
+        for field_name in config_dict.keys():
+            click.secho(f"  {field_name}", fg='yellow')
+        return
+
+    # Validate the provided value against the field's type
+    field_type = {f.name: f.type for f in fields(ChatConfig)}[key]
+    try:
+        # Dynamically cast the value to the correct type
+        if field_type == int:
+            value = int(value)
+        elif field_type == float:
+            value = float(value)
+        elif field_type == str:
+            value = str(value)
+        else:
+            raise ValueError(f"Unsupported type: {field_type}")
+    except ValueError:
+        click.secho(f"Invalid value type for {key}. Expected {field_type.__name__}.", fg='red')
+        return
+
+    # Update the configuration
+    setattr(current_config, key, value)
+    save_config(current_config)
+    click.secho(f"Configuration updated: {key} = {value}", fg='green')
+
+
+if __name__ == "__main__":
+    cli.add_command(chat)
+    cli.add_command(chatui)
+    cli.add_command(config)
+    cli.add_command(history)
+    cli()

llm_to_cli-0.1.0/cli/main_extend.py

@@ -0,0 +1,30 @@
+import click
+
+
+@click.command()
+@click.argument("input", type=click.File("rb"), nargs=-1)
+@click.argument("output", type=click.File("wb"))
+def cli(input, output):
+    """This script works similar to the Unix `cat` command but it writes
+    into a specific file (which could be the standard output as denoted by
+    the ``-`` sign).
+
+    \b
+    Copy stdin to stdout:
+        inout - -
+
+    \b
+    Copy foo.txt and bar.txt to stdout:
+        inout foo.txt bar.txt -
+
+    \b
+    Write stdin into the file foo.txt
+        inout - foo.txt
+    """
+    for f in input:
+        while True:
+            chunk = f.read(1024)
+            if not chunk:
+                break
+            output.write(chunk)
+            output.flush()

llm_to_cli-0.1.0/cli/utils.py

@@ -0,0 +1,71 @@
+import json
+import sqlite3
+import uuid
+from datetime import datetime
+from typing import Any
+
+from core.config import history_db
+
+# Database setup
+DB_PATH = history_db
+
+def init_db():
+    """Initialize the SQLite database."""
+    with sqlite3.connect(DB_PATH) as conn:
+        cursor = conn.cursor()
+        cursor.execute("""
+            CREATE TABLE IF NOT EXISTS sessions (
+                id TEXT PRIMARY KEY,
+                start_time TEXT NOT NULL,
+                title TEXT NOT NULL,
+                chat_history TEXT NOT NULL
+            )
+        """)
+        conn.commit()
+
+
+def save_chat_history(history: list[dict], session_id: str = None, title: str = "Untitled Session") -> str:
+    """Save chat history to the database."""
+    session_id = session_id or str(uuid.uuid4())
+    with sqlite3.connect(DB_PATH) as conn:
+        cursor = conn.cursor()
+        cursor.execute("""
+            INSERT OR REPLACE INTO sessions (id, start_time, title, chat_history) 
+            VALUES (?, ?, ?, ?)
+        """, (session_id, datetime.now().strftime("%Y-%m-%d %H:%M:%S"), title, json.dumps(history)))  # Save history as JSON
+        conn.commit()
+        return session_id
+
+def get_chat_history(session_id: str = None):
+    """Retrieve chat history."""
+    with sqlite3.connect(DB_PATH) as conn:
+        cursor = conn.cursor()
+        if session_id:
+            cursor.execute("SELECT id, start_time, title, chat_history FROM sessions WHERE id = ?", (session_id,))
+            row = cursor.fetchone()
+            if row:
+                row = row[:-1] + (json.loads(row[-1]),)  
+            return row
+        else:
+            cursor.execute("SELECT id, start_time, title, chat_history FROM sessions")
+            rows = cursor.fetchall()
+            return [(row[0], row[1], row[2], len(json.loads(row[3]))) for row in rows]
+
+
+def delete_chat_session(session_id:str=None):
+    """Delete a chat session by ID."""
+    
+    if session_id.strip() == 'all':
+        with sqlite3.connect(DB_PATH) as conn:
+            cursor = conn.cursor()
+            cursor.execute("DELETE FROM sessions")
+            conn.commit()
+        
+    else:
+        with sqlite3.connect(DB_PATH) as conn:
+            cursor = conn.cursor()
+            cursor.execute("DELETE FROM sessions WHERE id = ?", (session_id,))
+            conn.commit()
+        
+    return
+    

llm_to_cli-0.1.0/core/chat.py

@@ -0,0 +1,101 @@
+import base64
+import os
+import random
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List, Tuple
+
+import litellm
+from litellm import completion
+from pydantic_core.core_schema import tuple_positional_schema
+
+from .config import config_dir
+
+
+def chat(*args, **kwargs):
+    return completion(*args, **kwargs)
+
+def is_vision_llm(model:str)->bool:
+    return litellm.supports_vision(model)
+
+def encode_image(image_path: str |Path) -> str:
+    if isinstance(image_path, str):
+        image_path = Path(image_path)
+    
+    if not image_path.exists() or not image_path.is_file():
+        raise FileNotFoundError(f"Image not found at {image_path}")
+        
+    with open(image_path, "rb") as image_file:
+        return base64.b64encode(image_file.read()).decode('utf-8')
+    
+def is_url(path:Path)->bool:
+    return path.as_posix().startswith("http")
+
+def parse_image(image:str|Path, message:str=None)->list[dict]:
+    if isinstance(image, str):
+        image = Path(image)
+
+    if url:=is_url(image):
+        base_image = image.as_posix()
+    else:
+        try:
+            base_image = encode_image(image)
+        except FileNotFoundError as e:
+            return []
+
+    message_part =[]
+    if message:
+        message_part.append({
+                                "type": "text",
+                                "text": message
+                            })
+    if base_image:
+        message_part.append(
+                            {
+                                "type": "image_url",
+                                "image_url": {
+                                "url": base_image if url else f"data:image/jpeg;base64,{base_image}"
+                                }
+                            }
+        )
+        
+    return message_part
+    
+
+
+def random_name() -> str:
+    return f"{datetime.now().strftime('%Y%m%d-%H%M%S.%f')}-{random.randint(100000000, 9999999999)}"
+
+def unparse_image(message: List[Dict], config_dir: str = config_dir/'attached_images') -> Tuple[str, str]:
+    """
+    Get user message and image file path from a parsed message.
+    
+    Args:
+        message (list[dict]): Parsed message containing text and/or image data.
+        config_dir (str): Directory to save decoded images.
+        
+    Returns:
+        Tuple[str, str]: A tuple containing the user message and the saved image file path.
+    """
+    user_message = None
+    image_path = None
+
+    # Ensure config_dir exists
+    os.makedirs(config_dir, exist_ok=True)
+
+    for part in message:
+        if part["type"] == "text":
+            user_message = part["text"]
+        elif part["type"] == "image_url":
+            image_data = part["image_url"]["url"]
+            if image_data.startswith("data:image/jpeg;base64,"):
+                # Decode base64 image and save it
+                image_data = image_data.split(",", 1)[1]  # Remove the `data:image/jpeg;base64,` prefix
+                decoded_image = base64.b64decode(image_data)
+                image_path = Path(config_dir) / f"{random_name()}.jpg"
+                with open(image_path, "wb") as f:
+                    f.write(decoded_image)
+            else:
+                image_path = image_data
+
+    return user_message, str(image_path) if image_path else None

llm_to_cli-0.1.0/core/config.py

@@ -0,0 +1,39 @@
+import json
+import os
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+config_dir = os.path.expanduser('~/.llm-cli')
+config_dir = Path(config_dir)
+config_dir.mkdir(parents=True, exist_ok=True)
+
+config_file = config_dir/'config.json'
+history_db = config_dir/'chat_history.db'
+
+
+
+@dataclass
+class ChatConfig:
+    model:str = 'gemini/gemini-1.5-flash'
+    temperature:float = 0.2
+    max_token_output:int = 8192
+    
+
+def save_config(config:ChatConfig=None, config_file:Path=config_file)->None:
+    
+    if config is None:
+        config = ChatConfig()
+        
+    config = asdict(config)
+    with open(config_file, 'w') as f:
+        json.dump(config,f)
+    
+    
+
+def load_config() -> ChatConfig:
+    """Load configuration from a JSON file."""
+    if os.path.exists(config_file):
+        with open(config_file, 'r') as f:
+            config_data = json.load(f)
+        return ChatConfig(**config_data)
+    return ChatConfig()  

llm_to_cli-0.1.0/core/prompt.py

@@ -0,0 +1,2 @@
+system_prompt = 'You are a Helpful assistant'
+system_prompt_cot = "You are Intelligent, logical, anlytical, rational person. if Questions is factual answer in a single step, if questions are mathematical, reasoning, or requires stepwise thought, Think in steps. Develop a rationale"

llm_to_cli-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[tool.poetry]
+name = "llm-to-cli"
+version = "0.1.0"
+description = ""
+authors = ["tikendraw <tikendraksahu1029@gmail.com>"]
+readme = "README.md"
+
+packages = [
+    { include = "cli" },
+    { include = "core" },
+]
+
+[tool.poetry.dependencies]
+python = "^3.11"
+litellm = "^1.52.16"
+click = "^8.1.7"
+rich = "^13.9.4"
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.scripts]
+llm-cli = 'cli.main:cli'