Introduction

Generative AI is revolutionizing the way we interact with technology, enabling the creation of intelligent assistants capable of understanding and generating human-like text. In this guide, we will walk you through building a Generative AI assistant using Python, Groq, and Meta’s LLaMA 3 model. By the end of this tutorial, you’ll have a functional AI assistant capable of answering questions, generating text, and more.

Prerequisites

Before we begin, ensure you have the following:

• Python 3.8+ installed
• Access to Groq API
• LLaMA 3 model setup (either locally or through an API)
• Basic understanding of Python and machine learning
• Required Python libraries: groq, transformers, torch, flask (for building an API)

Step 1: Setting Up the Environment

First, install the necessary dependencies by running:

pip install groq transformers torch flask

Step 2: Accessing LLaMA 3 via Groq API

If you’re using Groq’s API to access LLaMA 3, you need an API key. Once you have it, you can initialize the connection in Python:

import groq 
API_KEY = "your_groq_api_key"
groq_client = groq.Client(api_key=API_KEY)

Step 3: Loading the LLaMA 3 Model Locally

Alternatively, if you want to run LLaMA 3 locally, you can use the transformers library:

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_name = "meta-llama-3"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype=torch.float16, device_map="auto")

Step 4: Creating the AI Assistant Function

Now, we create a function to generate responses using the LLaMA 3 model:

def generate_response(prompt):
    inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
    output = model.generate(**inputs, max_length=512)
    response = tokenizer.decode(output[0], skip_special_tokens=True)
    return response

If using Groq’s API:

def generate_response_groq(prompt):
    response = groq_client.chat.completions.create(
        model="llama-3",
        messages=[{"role": "system", "content": "You are a helpful AI assistant."},
                  {"role": "user", "content": prompt}]
    )
    return response.choices[0].message["content"]

Step 5: Building an API Endpoint with Flask

To make our assistant accessible via an API, we use Flask:

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route("/chat", methods=["POST"])
def chat():
    data = request.json
    user_input = data.get("message", "")
    response = generate_response(user_input)
    return jsonify({"response": response})

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)

Step 6: Testing the AI Assistant

Run the Flask app:

python app.py

Send a request using curl or Postman:

curl -X POST "http://localhost:5000/chat" -H "Content-Type: application/json" -d '{"message": "Hello, how are you?"}'

Conclusion

Congratulations! You have successfully built a Generative AI assistant using Python, Groq, and LLaMA 3. You can expand its functionality by fine-tuning the model, integrating it into a chatbot interface, or deploying it to the cloud for scalability.