nanochain 0.3

NanoChain is a Python library designed to provide a suite of useful tools for text processing, vector indexing, and utilizing OpenAI's GPT API to perform various tasks. This is a minimalistic implementation of LangChain because it's too complicated and difficult to customize.

NanoChain Library Documentation

NanoChain is a Python library designed to provide a suite of useful tools for text processing, vector indexing, and utilizing OpenAI's GPT-3.5-turbo model to perform various tasks.

Features

• GPT API Completion
• Summary buffer memory for conversation summarization
• Text file and PDF file loader
• Text splitting for large texts
• Vector indexing using the ChromaDB library
• ReActAgent for performing tasks using available tools

Installation

To install:

pip install nanochain

Usage

In order to use the NanoChain library, import it into your Python script as shown below:

import nanochain

# Set up OpenAI Key
export OPENAI_API_KEY='sk-...'
# or
import openai
openai.api_key = "sk-..."

GPT API Completion

The get_API_Response function is used to interact with the GPT-3.5-turbo API. It sends a prompt and returns the response from the model.

Input:

• prompt (string): The message for which you want to generate a response.
• system_prompt (string, optional): The prompt to use as the system text in the conversation history. Default is "You are a helpful assistant".
• stop (string, optional): A sequence of characters at which generation should stop.

Output:

• response (string): The generated response from GPT-3.5-Turbo.

Example usage:

response = nanochain.get_API_Response("What is the capital of France?")
print(response)

SummaryBufferMemory

The SummaryBufferMemory class is used to store and summarize a conversation. It can be initialized with an optional word_limit parameter.

When using with GPT, you mainly pass the buffer_messages_string() and summary to GPT as the prompt.

Methods/Attributes:

• 'buffer_messages_string()' returns a string representation of all messages currently in the buffer.
• 'summarize_messages()' generates a summary of all messages in the buffer and returns it as a string. The summary is generated using an API call that summarizes conversation history in 150 words or less.
• 'add_message(role, message)' adds a new message to the buffer. The 'role' parameter is a string representing who sent the message (either "AI" or "human"), and 'message' is a string representing the content of the message.
• 'delete_last_message()' removes the last message added to the buffer.
• 'count_words(text)' counts the number of words in a given text string.
• all_messages: A list of all messages.
• summary: A string containing the summary of the conversation so far.

Example usage:

# Create a new SummaryBufferMemory object with a word limit of 500
sbm = SummaryBufferMemory(word_limit=500)

# Add some messages to the buffer
sbm.add_message("AI", "Hello, how can I help you today?")
sbm.add_message("human", "I'm having trouble with my email.")
sbm.add_message("AI", "What seems to be the problem?")

# Generate a summary of the conversation so far
summary = sbm.summarize_messages()
print(summary)

# Delete the last message added to the buffer
sbm.delete_last_message()

# Add another message
sbm.add_message("human", "I keep getting an error message when I try to send an email.")

# Check the current contents of the buffer
buffer_str = sbm.buffer_messages_string()
print(buffer_str)

File loader

The load_files_from_path function is used to load all the pdf and txt file in a directory or a single pdf/txt file. The function returns a list of tuples (file_name, content_string).

Example usage:

pdf_text = nanochain.load_files_from_path("document.pdf")
print(pdf_text[0][1])

txt_text = nanochain.load_files_from_path("document.txt")
print(txt_text[0][1])

Text splitting

The text_splitter function is used to split a large text into smaller sections, optionally with a specified overlap between sections.

Example usage:

sections = nanochain.text_splitter(text, n_words=500, overlap=50)
print(sections)

Vector Database

The vectorIndex class is used for indexing and querying text documents using the ChromaDB library.

Methods/Attributes:

• vectorIndex(documents): Initializes a new vector index object with the given documents. The documents parameter is a list of strings, where each string represents a document to be added to the index.
• add_documents(documents): Adds new documents to the index. The documents parameter is a list of strings, where each string represents a document to be added.
• query_documents(query_string, n_results=3): Executes a query against the index and returns the top n matching results as a dictionary. The query_string parameter is a string representing the query to execute, and n_results is an optional integer that specifies the maximum number of results to return (default value is 3).
• delete_documents(ids): Deletes the documents with the specified ids from the index. The ids parameter is a list of strings, where each string represents the id of a document to be deleted.
• persist(): saves the database to a local directory.

Example usage:

vector_index = nanochain.vectorIndex(documents=["Document 1", "Document 2"])
vector_index.add_documents(documents=["Document 3", "Document 4"])
results = vector_index.query_documents(query_string="Search query")
print(results)

ReActAgent

The ReActAgent class is designed to perform tasks using available tools. You can add or remove tools, and run the agent with a given task string.

Methods/Attributes:

• ReActAgent(verbose=False, max_steps=10): Initializes a new ReActAgent object. The verbose parameter is an optional boolean that determines whether to print out the thought/action/action input/observation for each step (default is False). The max_steps parameter is an optional integer that specifies the maximum number of steps allowed before the agent stops (default is 10).
• add_tool(tool): Adds a new tool to the list of available tools. The tool parameter is a tuple with three elements: a string representing the name of the tool, a string representing the description of the tool, and a callable function that represents the implementation of the tool.
• remove_tool(tool_name): Removes a tool from the list of available tools by its name.
• get_action(task_string): Generates a string representation of the next action to take based on the current task. The task_string parameter is a string representing the input task/question.
• parse_and_execute(action_string): Parses an action string into its corresponding thought, action, action input, and observation, and executes the appropriate tool function. The action_string parameter is a string representing the action to take.
• run(task_string): Executes the entire ReAct process, taking steps until a final answer is generated or the maximum number of steps is reached. The task_string parameter is a string representing the input task/question.

Example usage:

agent = nanochain.ReActAgent(verbose=True, max_steps=10)
agent.add_tool(("New tool", "New tool description", function_name))
agent.remove_tool("New tool")

task_string = "Find the capital of France."
result = agent.run(task_string)
print(result)

Recursive Summary

The get_recursive_summary function is used to generate a summary of a text using a recursive summarization algorithm.

Example usage:

summary = nanochain.get_recursive_summary(text)