Building a Tool To Generate Text With OpenAI’s GPT-4 Model

Build a text generation tool using OpenAI's GPT-4. Set up your environment, authenticate the API, make API calls, handle errors, and integrate with Flask for a web app.

Neha Dhaliwal

Jun. 06, 24 · Tutorial

Like (4)

Save

2.3K Views

In this tutorial, we will guide you through the process of building a tool that utilizes OpenAI's GPT-4 model to produce text based on user prompts. We will cover setting up your environment, making API calls to OpenAI's model, and integrating the tool into a basic application. By the end of this tutorial, you will have a functional tool that can generate text by interacting with OpenAI's GPT-4 model.

Prerequisites

Basic understanding of Python programming
An OpenAI API key (sign up at OpenAI's website if you don't have one)
A working Python environment (Python 3.7+)

Step 1: Setting up Your Environment

First, you need to install the OpenAI Python client library. Open your terminal and run:

    Shell
   
   pip install openai

Next, create a new Python file for your project, e.g., text_generation_tool.py.

Step 2: Authenticating With the OpenAI API

In your Python file, start by importing the necessary libraries and setting up your API key:

    Python
   
   import openai
import os

# Replace 'your-api-key' with your actual OpenAI API key
openai.api_key = os.environ.get("OPENAI_API_KEY", "your-api-key")

It's recommended to store your API key as an environment variable for better security. If you're using a local environment, you can set the OPENAI_API_KEY environment variable before running your script.

Step 3: Making Your First API Call

To generate text, you need to interact with the OpenAI API's completion endpoint. Here's a basic example of how to do this:

    Python
   
   response = openai.Completion.create(
    engine="text-davinci-004",  # GPT-4 model variant
    prompt="Once upon a time",
    max_tokens=100  # Adjust the number of tokens as needed
)

generated_text = response.choices[0].text.strip()
print(generated_text)

This code sends a prompt to the OpenAI API and prints the generated text.

Step 4: Enhancing the Prompt

A good prompt is key to getting meaningful results. Let's make the prompt more specific and control the model's behavior using parameters:

    Python
   
 

   prompt = """
Write a short story about a dragon who befriends a young girl in a small village. Make it whimsical and heartwarming.
"""

response = openai.Completion.create(
    engine="text-davinci-004",
    prompt=prompt,
    max_tokens=150,  # Increased token limit for a longer story
    temperature=0.7,  # Controls creativity; higher values = more creative
    n=1,  # Number of responses to generate
    stop=["The end."]  # Stop generating when this sequence is encountered
)

generated_text = response.choices[0].text.strip()
print(generated_text)

  

Step 5: Error Handling and Optimization

To handle potential errors and optimize your API calls, add error handling and consider caching results for repeated prompts.

    Python
   
 

   import openai
import os
import logging

openai.api_key = os.environ.get("OPENAI_API_KEY", "your-api-key")

def generate_text(prompt):
    try:
        response = openai.Completion.create(
            engine="text-davinci-004",
            prompt=prompt,
            max_tokens=150,
            temperature=0.7,
            n=1,
            stop=["The end."]
        )
        return response.choices[0].text.strip()
    except openai.error.OpenAIError as e:
        logging.error(f"OpenAI API error: {e}")
        return "Sorry, I'm having trouble generating text right now."

prompt = "Write a short story about a dragon who befriends a young girl in a small village. Make it whimsical and heartwarming."

generated_text = generate_text(prompt)
print(generated_text)

  

Step 6: Integrating With a Simple Web Application

For this example, we'll use Flask to create a simple web application where users can input a prompt and get a generated response.

Install Flask:

    Shell
   
   pip install Flask

Create a new file app.py and add the following code:

    Python
   
 

   from flask import Flask, request, render_template
import openai
import os

app = Flask(__name__)
openai.api_key = os.environ.get("OPENAI_API_KEY", "your-api-key")

def generate_text(prompt):
    try:
        response = openai.Completion.create(
            engine="text-davinci-004",
            prompt=prompt,
            max_tokens=150,
            temperature=0.7,
            n=1,
            stop=["The end."]
        )
        return response.choices[0].text.strip()
    except openai.error.OpenAIError as e:
        return f"Error: {e}"

@app.route('/')
def index():
    return render_template('index.html')

@app.route('/generate', methods=['POST'])
def generate_response():
    prompt = request.form['prompt']
    generated_text = generate_text(prompt)
    return render_template('index.html', prompt=prompt, generated_text=generated_text)

if __name__ == '__main__':
    app.run(debug=True)

  

Create a new folder called templates and inside it, create a file named index.html:

HTML

{% if generated_text %}

Generated Text:

{% endif %} " data-lang="text/html">

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Text Generation Tool</title>
</head>
<body>
    <h1>Text Generation Tool</h1>
    <form action="/generate" method="post">
        <textarea name="prompt" rows="5" cols="50" placeholder="Enter your prompt here...">{{ prompt }}</textarea><br>
        <input type="submit" value="Generate">
    </form>
    {% if generated_text %}
        <h2>Generated Text:</h2>
        <p>{{ generated_text }}</p>
    {% endif %}
</body>
</html>

Run your Flask application:

    Python
   
   export OPENAI_API_KEY=your-api-key  # Set the environment variable
python app.py

Open your browser and go to http://127.0.0.1:5000/. You should see a form where you can input a prompt and get generated text in response.

Conclusion

In this tutorial, we have covered how to set up a tool that utilizes OpenAI's GPT-4 model to generate text based on user prompts. We've explored making API calls, handling errors, and integrating the tool into a simple web application.

Web application Flask (web framework) ChatGPT

Opinions expressed by DZone contributors are their own.

Related

Trending