How to bypass the TTL of 30 seconds while waiting response of post request from external server

the response from chat-gpt is taking more than 30 seconds (we are having a long prompts)

That means you need an asynchronous processing, which is a common pattern in distributed systems to handle long running tasks or slow external dependencies.

Your current setup is:

Client --(HTTP POST)--> Django View --(API Call)--> External Service (GPT API)

To implement your idea, you might consider Celery for task processing, RabbitMQ as the message broker, and Django for handling HTTP requests.

Client ------(HTTP POST)------> Django View ------(Message)------> RabbitMQ
                                      |                               |
                                      |<----------(Polling)-----------|
                                      |                               |
                                      |-----------(Task)------------->| Celery -----(API Call)----> External Service
                                      |                       b       |                              |
                                      |<----------(Response)----------|<-----------------------------|

Install Celery in your Django project and set up RabbitMQ as the message broker (bundle: pip install celery[redis]), and configure it to use RabbitMQ as the message broker: create a new file named celery.py in your main Django app directory:

from __future__ import absolute_import, unicode_literals
import os
from celery import Celery

# set the default Django settings module for the 'celery' program.
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'your_project.settings')

app = Celery('your_project')

app.config_from_object('django.conf:settings', namespace='CELERY')

# Load task modules from all registered Django app configs.
app.autodiscover_tasks()

Then create a Celery task to handle the GPT API call:

# tasks.py in one of your apps
import openai
from django.conf import settings
from celery import shared_task

@shared_task
def get_gpt_response(prompt, message_id):
    openai.api_key = settings.OPENAI_KEY
    response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[{"role": "user", "content": prompt}],
    )
    # Store the response in your database against the message_id
    # rest of your code

Modify your Django view to enqueue the task and return a message ID to the client.

from app.tasks import get_gpt_response
from uuid import uuid4
# other imports/code

@login_required
def form_prompt(request: HttpRequest, pk: int) -> HttpResponse:
    instance = get_object_or_404(ModelName, pk=pk)
    form = PromptForm(request.POST or None, instance=setkeyword)
    if form.is_valid():
        prompt = form.cleaned_data["text"]
        message_id = str(uuid4())  # Generate a unique message ID
        get_gpt_response.delay(prompt, message_id)  # Enqueue the task
        # Store the message ID and initial status in your database
        return JsonResponse({'message_id': message_id})  # Return the message ID to the client
    return render(request, "view_prompt_name.html", context)

Create a new Django view to handle polling requests from the client, using JsonResponse .

from django.http import JsonResponse
# other import/code

def check_status(request: HttpRequest, message_id: str) -> HttpResponse:
    # Retrieve the status and possibly the response from your database using the message_id
    # 
    # If response is ready, return it to the client
    # else return a 'pending' status
    # 

Now, the TTL of 30 seconds should no longer be a problem, since the client will keep polling the server for the response, and the server will respond with the actual result once it is ready.

See also:

• "Celery using RabbitMQ" and "Getting Started with Celery & RabbitMQ" from Hitesh Mishra
• "Celery First steps with Django"

---

When arrived to the get_gpt_response.delay(prompt, message_id) # Enqueue the task, I got this message, error: kombu.exceptions.OperationalError: [Errno 111] Connection refused I am wondering if I correctly initiated celery.

The error kombu.exceptions.OperationalError: [Errno 111] Connection refused you are encountering is typically associated with Celery being unable to connect to the message broker (like RabbitMQ or Redis). That could be due to several reasons such as the broker service not running, incorrect broker URL, or network issues.

The solution on GitHub celery/kombu issue 1582 mentions adds the broker and backend settings to the Celery configuration, and makes sure the Redis server is running.
You may need to adapt your Celery configuration similarly.

import os
from celery import Celery
from django.conf import settings

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'your_project.settings')

# Use Redis as the broker if it exists
app = Celery('your_project', broker="redis://localhost:6379", backend="redis://localhost:6379")

app.config_from_object('django.conf:settings')

# Load task modules from all registered Django app configs.
app.autodiscover_tasks(settings.INSTALLED_APPS)

BROKER_URL = "redis://localhost:6379"
broker_url = "redis://localhost:6379"
app.conf.broker_url = BROKER_URL
CELERY_BROKER_URL = BROKER_URL

app.conf.beat_schedule = {
    # any periodic tasks you have
}

@app.task
def debug_task():
    print(f'Request: {self.request!r}')