Building a Chat Assistant with Gorq and Python Async: A Step-by-Step Guide

2024-11-06•Basic•4 min

In this blog, we’ll walk you through using Gorq, a Python library that helps us connect with and interact with powerful AI models asynchronously. By the end, you’ll have a basic chat assistant running, with the ability to handle user questions using an AI model via Gorq. Let’s dive in!

What is Gorq?

Gorq is a library designed to simplify interactions with large language models, allowing you to set up and send asynchronous requests easily. This can be especially useful for building applications requiring real-time responses, such as chatbots, virtual assistants, and interactive tools.

Setting Up the Project

Before we begin coding, ensure you have Python 3.7+ installed, as we’ll use asynchronous functions extensively. You’ll also need an API key from Gorq to authenticate your requests. You can get an API key by signing up on the Gorq platform.

Visit this page and grab you Gorq API Key

click here

Step 1: Install the Gorq Package

First, install the Gorq package. Open your terminal and run:

pip install groq

Step 2: Write the Code for the Chat Assistant

We’ll be using asynchronous programming in Python with the asyncio library, which will allow our assistant to process messages efficiently.

Here's the complete code to create a chat assistant using Gorq.

import asyncio
from groq import AsyncGroq

client = AsyncGroq(
    api_key="your_api_key_here",
)

async def query_assistant(question: str) -> str:
    chat_completion = await client.chat.completions.create(
        messages=[
            {
                "role": "user",
                "content": question,
            }
        ],
        model="mixtral-8x7b-32768",
    )
    return chat_completion.choices[0].message.content

async def main() -> None:
    print("Hello! I'm your AI assistant. How can I help you today?")
    while True:
        user_input = input("You: ")
        if user_input.lower() in ['exit', 'quit']:
            print("Goodbye!")
            break
        response = await query_assistant(user_input)
        print("AI: " + response)

asyncio.run(main())

Now, let’s break down what each part of the code does.

Importing Libraries

import asyncio
from groq import AsyncGroq

Here, we import asyncio and AsyncGroq. asyncio is Python’s standard library for running asynchronous functions, and AsyncGroq provides the functionality for making asynchronous API requests to Gorq.

Initialize the Client

client = AsyncGroq(
    api_key="your_api_key_here",
)

We create an AsyncGroq client using our API key. This client object lets us send queries and receive responses from the Gorq model.

Defining the Query Function

async def query_assistant(question: str) -> str:
    chat_completion = await client.chat.completions.create(
        messages=[
            {
                "role": "user",
                "content": question,
            }
        ],
        model="mixtral-8x7b-32768",
    )
    return chat_completion.choices[0].message.content

This asynchronous function, query_assistant, accepts a question string from the user. It sends this question to the Gorq model, which processes it and returns a response.

Inside query_assistant, we call client.chat.completions.create with:

messages: This is a list of messages exchanged between the user and the assistant. Each message has a role and content.

model: Specifies the AI model to use. Here, "mixtral-8x7b-32768" is an example model; you can select a model that best fits your needs.

Creating the Main Program Logic

async def main() -> None:
    print("Hello! I'm your AI assistant. How can I help you today?")
    while True:
        user_input = input("You: ")
        if user_input.lower() in ['exit', 'quit']:
            print("Goodbye!")
            break
        response = await query_assistant(user_input)
        print("AI: " + response)

In the main function:

The assistant greets the user.

We enter a loop, capturing user input and sending it to the query_assistant function.

If the user types "exit" or "quit", the program ends.

Otherwise, we call query_assistant(user_input) and print the AI’s response.

Running the Code

asyncio.run(main())

Finally, asyncio.run(main()) starts the event loop, running our main() function and managing all asynchronous calls within it.

Congratulations! You’ve just built a basic chat assistant using Gorq and Python’s asyncio. By understanding this framework, you can expand your assistant with more advanced features, including error handling, personalized responses, and support for additional queries.

With this setup, you’re well on your way to building a responsive, interactive AI-driven chatbot using Python!