Convert Figma logo to code with AI

minimaxir logosimpleaichat

Python package for easily interfacing with chat apps, with robust features and minimal code complexity.

3,466
228
3,466
55

Top Related Projects

The official Python library for the OpenAI API

🤗 Transformers: State-of-the-art Machine Learning for Pytorch, TensorFlow, and JAX.

A Gradio web UI for Large Language Models.

34,658

DeepSpeed is a deep learning optimization library that makes distributed training and inference easy, efficient, and effective.

36,658

An open platform for training, serving, and evaluating large language models. Release repo for Vicuna and Chatbot Arena.

Quick Overview

SimpleAIChat is a Python package that provides a simple interface for interacting with AI language models, particularly OpenAI's GPT models. It offers an easy-to-use API for creating chat-based applications and integrating AI-powered conversations into various projects.

Pros

  • Simple and intuitive API for AI chat interactions
  • Supports multiple AI models, including OpenAI's GPT models
  • Includes features like conversation history management and streaming responses
  • Offers customization options for prompts and system messages

Cons

  • Limited to text-based interactions (no image or audio support)
  • Requires an API key for OpenAI or other supported services
  • May have limitations based on the underlying AI model's capabilities
  • Potential costs associated with API usage for commercial applications

Code Examples

  1. Basic chat interaction:
from simpleaichat import AIChat

ai = AIChat(api_key="your-api-key")
response = ai.chat("Tell me a joke about programming.")
print(response)
  1. Conversation with history:
ai = AIChat(api_key="your-api-key")
ai.chat("Hello, I'm learning Python.")
ai.chat("What's a good project idea for beginners?")
response = ai.chat("Can you explain how to start that project?")
print(response)
  1. Streaming response:
ai = AIChat(api_key="your-api-key")
for chunk in ai.stream("Explain the concept of recursion."):
    print(chunk, end="", flush=True)

Getting Started

To get started with SimpleAIChat:

  1. Install the package:

    pip install simpleaichat
    
  2. Import and initialize the AIChat class:

    from simpleaichat import AIChat
    
    ai = AIChat(api_key="your-api-key")
    
  3. Start chatting:

    response = ai.chat("Hello, AI!")
    print(response)
    

Make sure to replace "your-api-key" with your actual OpenAI API key or the appropriate key for the AI service you're using.

Competitor Comparisons

The official Python library for the OpenAI API

Pros of openai-python

  • Official OpenAI library, ensuring compatibility and up-to-date features
  • Comprehensive support for all OpenAI API endpoints
  • Extensive documentation and community support

Cons of openai-python

  • More complex setup and usage for beginners
  • Requires manual handling of conversation context and history
  • Less abstraction for common chat-based use cases

Code Comparison

simpleaichat:

from simpleaichat import AIChat

ai = AIChat()
response = ai.chat("Hello, how are you?")
print(response)

openai-python:

import openai

openai.api_key = "your-api-key"
response = openai.ChatCompletion.create(
    model="gpt-3.5-turbo",
    messages=[{"role": "user", "content": "Hello, how are you?"}]
)
print(response.choices[0].message.content)

simpleaichat provides a more straightforward interface for basic chat interactions, while openai-python offers greater flexibility and control over API parameters. The official library requires more setup but provides access to a wider range of OpenAI services beyond just chat functionality.

🤗 Transformers: State-of-the-art Machine Learning for Pytorch, TensorFlow, and JAX.

Pros of transformers

  • Extensive library with support for numerous pre-trained models and architectures
  • Robust documentation and community support
  • Seamless integration with PyTorch and TensorFlow

Cons of transformers

  • Steeper learning curve for beginners
  • Larger codebase and potentially higher resource requirements
  • May be overkill for simple AI chat applications

Code Comparison

simpleaichat:

from simpleaichat import AIChat

ai = AIChat(api_key="YOUR_API_KEY")
response = ai.chat("Hello, how are you?")
print(response)

transformers:

from transformers import pipeline

chatbot = pipeline("conversational")
response = chatbot("Hello, how are you?")
print(response[0]["generated_text"])

Summary

transformers offers a comprehensive suite of tools for working with various transformer models, making it ideal for complex NLP tasks and research. simpleaichat, on the other hand, provides a more streamlined approach for basic AI chat interactions, making it easier to use for simple applications but with less flexibility for advanced use cases.

A Gradio web UI for Large Language Models.

Pros of text-generation-webui

  • More comprehensive UI with advanced features like chat, notebook, and training interfaces
  • Supports a wider range of models and architectures
  • Offers more customization options and fine-tuning capabilities

Cons of text-generation-webui

  • Steeper learning curve due to more complex setup and configuration
  • Requires more computational resources to run effectively
  • Less suitable for quick, simple interactions or integration into other projects

Code Comparison

text-generation-webui:

def generate_reply(
    question, state, stopping_strings=None, is_chat=False, for_ui=False
):
    # Complex generation logic with multiple parameters and options
    # ...

simpleaichat:

def generate(
    self, prompt: str, system: str = "", **kwargs
) -> str:
    # Simpler generation function with fewer parameters
    # ...

The code comparison shows that text-generation-webui offers more advanced generation options, while simpleaichat provides a more straightforward interface for basic interactions. text-generation-webui is better suited for users who need extensive customization and advanced features, while simpleaichat is ideal for those seeking a simpler, more accessible solution for AI chat interactions.

34,658

DeepSpeed is a deep learning optimization library that makes distributed training and inference easy, efficient, and effective.

Pros of DeepSpeed

  • Highly optimized for large-scale distributed training of deep learning models
  • Supports a wide range of AI models and architectures
  • Offers advanced features like ZeRO optimizer and 3D parallelism

Cons of DeepSpeed

  • Steeper learning curve due to its complexity and advanced features
  • Primarily focused on training, less emphasis on inference or deployment
  • Requires more setup and configuration for optimal performance

Code Comparison

SimpleAIChat:

from simpleaichat import AIChat

ai = AIChat(api_key="YOUR_API_KEY")
response = ai.chat("Hello, how are you?")
print(response)

DeepSpeed:

import deepspeed
import torch

model, optimizer, _, _ = deepspeed.initialize(args=args,
                                              model=model,
                                              model_parameters=params)
output = model(input_ids)

Key Differences

SimpleAIChat is designed for simplicity and ease of use, focusing on quick integration of AI chat capabilities. DeepSpeed, on the other hand, is a comprehensive library for optimizing and scaling deep learning training, offering advanced features for high-performance computing environments.

While SimpleAIChat is ideal for rapid prototyping and simple AI chat applications, DeepSpeed is better suited for large-scale, distributed training of complex AI models, particularly in research and enterprise settings.

36,658

An open platform for training, serving, and evaluating large language models. Release repo for Vicuna and Chatbot Arena.

Pros of FastChat

  • More comprehensive and feature-rich, offering a complete server setup for deploying and interacting with various language models
  • Supports multiple models and architectures, including Llama, Vicuna, and ChatGLM
  • Provides a web interface and RESTful API for easy integration and usage

Cons of FastChat

  • More complex setup and configuration process
  • Requires more computational resources due to its broader scope and functionality
  • Steeper learning curve for users who only need basic chat functionality

Code Comparison

SimpleAIChat:

from simpleaichat import AIChat

ai = AIChat(api_key="YOUR_API_KEY")
response = ai.chat("Hello, how are you?")
print(response)

FastChat:

from fastchat.model import load_model, get_conversation_template
from fastchat.serve.inference import chat_loop

model, tokenizer = load_model("vicuna-7b")
conv = get_conversation_template("vicuna")
chat_loop(model, tokenizer, conv)

Summary

SimpleAIChat focuses on providing a straightforward interface for chatting with AI models, particularly OpenAI's GPT models. It's ideal for users who need quick and easy integration of AI chat functionality into their projects.

FastChat, on the other hand, offers a more comprehensive solution for deploying and interacting with various language models. It provides a complete server setup, supports multiple models, and includes additional features like a web interface and API. However, this comes at the cost of increased complexity and resource requirements.

Convert Figma logo designs to code with AI

Visual Copilot

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

simpleaichat

from simpleaichat import AIChat

ai = AIChat(system="Write a fancy GitHub README based on the user-provided project name.")
ai("simpleaichat")

simpleaichat is a Python package for easily interfacing with chat apps like ChatGPT and GPT-4 with robust features and minimal code complexity. This tool has many features optimized for working with ChatGPT as fast and as cheap as possible, but still much more capable of modern AI tricks than most implementations:

  • Create and run chats with only a few lines of code!
  • Optimized workflows which minimize the amount of tokens used, reducing costs and latency.
  • Run multiple independent chats at once.
  • Minimal codebase: no code dives to figure out what's going on under the hood needed!
  • Chat streaming responses and the ability to use tools.
  • Async support, including for streaming and tools.
  • Ability to create more complex yet clear workflows if needed, such as Agents. (Demo soon!)
  • Coming soon: more chat model support (PaLM, Claude)!

Here's some fun, hackable examples on how simpleaichat works:

Installation

simpleaichat can be installed from PyPI:

pip3 install simpleaichat

Quick, Fun Demo

You can demo chat-apps very quickly with simpleaichat! First, you will need to get an OpenAI API key, and then with one line of code:

from simpleaichat import AIChat

AIChat(api_key="sk-...")

And with that, you'll be thrust directly into an interactive chat!

This AI chat will mimic the behavior of OpenAI's webapp, but on your local computer!

You can also pass the API key by storing it in an .env file with a OPENAI_API_KEY field in the working directory (recommended), or by setting the environment variable of OPENAI_API_KEY directly to the API key.

But what about creating your own custom conversations? That's where things get fun. Just input whatever person, place or thing, fictional or nonfictional, that you want to chat with!

AIChat("GLaDOS")  # assuming API key loaded via methods above

But that's not all! You can customize exactly how they behave too with additional commands!

AIChat("GLaDOS", "Speak in the style of a Seinfeld monologue")

AIChat("Ronald McDonald", "Speak using only emoji")

Need some socialization immediately? Once simpleaichat is installed, you can also start these chats directly from the command line!

simpleaichat
simpleaichat "GlaDOS"
simpleaichat "GLaDOS" "Speak in the style of a Seinfeld monologue"

Building AI-based Apps

The trick with working with new chat-based apps that wasn't readily available with earlier iterations of GPT-3 is the addition of the system prompt: a different class of prompt that guides the AI behavior throughout the entire conversation. In fact, the chat demos above are actually using system prompt tricks behind the scenes! OpenAI has also released an official guide for system prompt best practices to building AI apps.

For developers, you can instantiate a programmatic instance of AIChat by explicitly specifying a system prompt, or by disabling the console.

ai = AIChat(system="You are a helpful assistant.")
ai = AIChat(console=False)  # same as above

You can also pass in a model parameter, such as model="gpt-4" if you have access to GPT-4, or model="gpt-3.5-turbo-16k" for a larger-context-window ChatGPT.

You can then feed the new ai class with user input, and it will return and save the response from ChatGPT:

response = ai("What is the capital of California?")
print(response)
The capital of California is Sacramento.

Alternatively, you can stream responses by token with a generator if the text generation itself is too slow:

for chunk in ai.stream("What is the capital of California?", params={"max_tokens": 5}):
    response_td = chunk["response"]  # dict contains "delta" for the new token and "response"
    print(response_td)
The
The capital
The capital of
The capital of California
The capital of California is

Further calls to the ai object will continue the chat, automatically incorporating previous information from the conversation.

response = ai("When was it founded?")
print(response)
Sacramento was founded on February 27, 1850.

You can also save chat sessions (as CSV or JSON) and load them later. The API key is not saved so you will have to provide that when loading.

ai.save_session()  # CSV, will only save messages
ai.save_session(format="json", minify=True)  # JSON

ai.load_session("my.csv")
ai.load_session("my.json")

Functions

A large number of popular venture-capital-funded ChatGPT apps don't actually use the "chat" part of the model. Instead, they just use the system prompt/first user prompt as a form of natural language programming. You can emulate this behavior by passing a new system prompt when generating text, and not saving the resulting messages.

The AIChat class is a manager of chat sessions, which means you can have multiple independent chats or functions happening! The examples above use a default session, but you can create new ones by specifying a id when calling ai.

json = '{"title": "An array of integers.", "array": [-1, 0, 1]}'
functions = [
             "Format the user-provided JSON as YAML.",
             "Write a limerick based on the user-provided JSON.",
             "Translate the user-provided JSON from English to French."
            ]
params = {"temperature": 0.0, "max_tokens": 100}  # a temperature of 0.0 is deterministic

# We namespace the function by `id` so it doesn't affect other chats.
# Settings set during session creation will apply to all generations from the session,
# but you can change them per-generation, as is the case with the `system` prompt here.
ai = AIChat(id="function", params=params, save_messages=False)
for function in functions:
    output = ai(json, id="function", system=function)
    print(output)
title: "An array of integers."
array:
  - -1
  - 0
  - 1
An array of integers so neat,
With values that can't be beat,
From negative to positive one,
It's a range that's quite fun,
This JSON is really quite sweet!
{"titre": "Un tableau d'entiers.", "tableau": [-1, 0, 1]}

Newer versions of ChatGPT also support "function calling", but the real benefit of that feature is the ability for ChatGPT to support structured input and/or output, which now opens up a wide variety of applications! simpleaichat streamlines the workflow to allow you to just pass an input_schema and/or an output_schema.

You can construct a schema using a pydantic BaseModel.

from pydantic import BaseModel, Field

ai = AIChat(
    console=False,
    save_messages=False,  # with schema I/O, messages are never saved
    model="gpt-3.5-turbo-0613",
    params={"temperature": 0.0},
)

class get_event_metadata(BaseModel):
    """Event information"""

    description: str = Field(description="Description of event")
    city: str = Field(description="City where event occured")
    year: int = Field(description="Year when event occured")
    month: str = Field(description="Month when event occured")

# returns a dict, with keys ordered as in the schema
ai("First iPhone announcement", output_schema=get_event_metadata)
{'description': 'The first iPhone was announced by Apple Inc.',
 'city': 'San Francisco',
 'year': 2007,
 'month': 'January'}

See the TTRPG Generator Notebook for a more elaborate demonstration of schema capabilities.

Tools

One of the most recent aspects of interacting with ChatGPT is the ability for the model to use "tools." As popularized by LangChain, tools allow the model to decide when to use custom functions, which can extend beyond just the chat AI itself, for example retrieving recent information from the internet not present in the chat AI's training data. This workflow is analogous to ChatGPT Plugins.

Parsing the model output to invoke tools typically requires a number of shennanigans, but simpleaichat uses a neat trick to make it fast and reliable! Additionally, the specified tools return a context for ChatGPT to draw from for its final response, and tools you specify can return a dictionary which you can also populate with arbitrary metadata for debugging and postprocessing. Each generation returns a dictionary with the response and the tool function used, which can be used to set up workflows akin to LangChain-style Agents, e.g. recursively feed input to the model until it determines it does not need to use any more tools.

You will need to specify functions with docstrings which provide hints for the AI to select them:

from simpleaichat.utils import wikipedia_search, wikipedia_search_lookup

# This uses the Wikipedia Search API.
# Results from it are nondeterministic, your mileage will vary.
def search(query):
    """Search the internet."""
    wiki_matches = wikipedia_search(query, n=3)
    return {"context": ", ".join(wiki_matches), "titles": wiki_matches}

def lookup(query):
    """Lookup more information about a topic."""
    page = wikipedia_search_lookup(query, sentences=3)
    return page

params = {"temperature": 0.0, "max_tokens": 100}
ai = AIChat(params=params, console=False)

ai("San Francisco tourist attractions", tools=[search, lookup])
{'context': "Fisherman's Wharf, San Francisco, Tourist attractions in the United States, Lombard Street (San Francisco)",
 'titles': ["Fisherman's Wharf, San Francisco",
  'Tourist attractions in the United States',
  'Lombard Street (San Francisco)'],
 'tool': 'search',
 'response': "There are many popular tourist attractions in San Francisco, including Fisherman's Wharf and Lombard Street. Fisherman's Wharf is a bustling waterfront area known for its seafood restaurants, souvenir shops, and sea lion sightings. Lombard Street, on the other hand, is a famous winding street with eight hairpin turns that attract visitors from all over the world. Both of these attractions are must-sees for anyone visiting San Francisco."}
ai("Lombard Street?", tools=[search, lookup])
{'context': 'Lombard Street is an east–west street in San Francisco, California that is famous for a steep, one-block section with eight hairpin turns. Stretching from The Presidio east to The Embarcadero (with a gap on Telegraph Hill), most of the street\'s western segment is a major thoroughfare designated as part of U.S. Route 101. The famous one-block section, claimed to be "the crookedest street in the world", is located along the eastern segment in the Russian Hill neighborhood.',
 'tool': 'lookup',
 'response': 'Lombard Street is a famous street in San Francisco, California known for its steep, one-block section with eight hairpin turns. It stretches from The Presidio to The Embarcadero, with a gap on Telegraph Hill. The western segment of the street is a major thoroughfare designated as part of U.S. Route 101, while the famous one-block section, claimed to be "the crookedest street in the world", is located along the eastern segment in the Russian Hill'}
ai("Thanks for your help!", tools=[search, lookup])
{'response': "You're welcome! If you have any more questions or need further assistance, feel free to ask.",
 'tool': None}

Miscellaneous Notes

  • Like gpt-2-simple before it, the primary motivation behind releasing simpleaichat is to both democratize access to ChatGPT even more and also offer more transparency for non-engineers into how Chat AI-based apps work under the hood given the disproportionate amount of media misinformation about their capabilities. This is inspired by real-world experience from my work with BuzzFeed in the domain, where after spending a long time working with the popular LangChain, a more-simple implementation was both much easier to maintain and resulted in much better generations. I began focusing development on simpleaichat after reading a Hacker News thread filled with many similar complaints, indicating value for an easier-to-use interface for modern AI tricks.
    • simpleaichat very intentionally avoids coupling features with common use cases where possible (e.g. Tools) in order to avoid software lock-in due to the difficulty implementing anything not explicitly mentioned in the project's documentation. The philosophy behind simpleaichat is to provide good demos, and let the user's creativity and business needs take priority instead of having to fit a round peg into a square hole like with LangChain.
    • simpleaichat makes it easier to interface with Chat AIs, but it does not attempt to solve common technical and ethical problems inherent to large language models trained on the internet, including prompt injection and unintended plagiarism. The user should exercise good judgment when implementing simpleaichat. Use cases of simpleaichat which go against OpenAI's usage policies (including jailbreaking) will not be endorsed.
    • simpleaichat intentionally does not use the "Agent" logical metaphor for tool workflows because it's become an AI hype buzzword heavily divorced from its origins. If needed be, you can emulate the Agent workflow with a while loop without much additional code, plus with the additional benefit of much more flexibility such as debugging.
  • The session manager implements some sensible security defaults, such as using UUIDs as session ids by default, storing authentication information in a way to minimize unintentional leakage, and type enforcement via Pydantic. Your end-user application should still be aware of potential security issues, however.
  • Although OpenAI's documentation says that system prompts are less effective than a user prompt constructed in a similar manner, in my experience it still does perform better for maintaining rules/a persona.
  • Many examples of popular prompts use more conversational prompts, while the example prompts here use more consise and imperative prompts. This aspect of prompt engineering is still evolving, but in my experience commands do better with ChatGPT and with greater token efficieny. That's also why simpleaichat allows users to specify system prompts (and explicitly highlights what the default use) instead of relying on historical best practices.
  • Token counts for async is not supported as OpenAI doesn't return token counts when streaming responses. In general, there may be some desync in token counts and usage for various use cases; I'm working on categorizing them.
  • Outside of the explicit examples, none of this README uses AI-generated text. The introduction code example is just a joke, but it was too good of a real-world use case!

Roadmap

  • PaLM Chat (Bard) and Anthropic Claude support
  • More fun/feature-filled CLI chat app based on Textual
  • Simple example of using simpleaichat in a webapp
  • Simple of example of using simpleaichat in a stateless manner (e.g. AWS Lambda functions)

Maintainer/Creator

Max Woolf (@minimaxir)

Max's open-source projects are supported by his Patreon and GitHub Sponsors. If you found this project helpful, any monetary contributions to the Patreon are appreciated and will be put to good creative use.

License

MIT