How to Integrate Replit with OpenAI GPT

1# Python — verify OpenAI key is available
2import os
3
4api_key = os.environ.get("OPENAI_API_KEY")
5if not api_key:
6    raise EnvironmentError(
7        "OPENAI_API_KEY not found. Add it in Replit Secrets (lock icon in sidebar)."
8    )
9if not api_key.startswith("sk-"):
10    raise ValueError("OPENAI_API_KEY appears invalid — should start with 'sk-'")
11print(f"API key loaded: {api_key[:8]}...")

1// Node.js — First OpenAI API call (test.js)
2const OpenAI = require('openai');
3
4const client = new OpenAI({
5  apiKey: process.env.OPENAI_API_KEY
6});
7
8async function testCompletion() {
9  const response = await client.chat.completions.create({
10    model: 'gpt-4o',
11    messages: [
12      {
13        role: 'system',
14        content: 'You are a helpful assistant. Be concise.'
15      },
16      {
17        role: 'user',
18        content: 'What is the capital of France? Answer in one sentence.'
19      }
20    ],
21    max_tokens: 50
22  });
23
24  console.log('Response:', response.choices[0].message.content);
25  console.log('Tokens used:', response.usage.total_tokens);
26}
27
28testCompletion().catch(console.error);

1// Node.js — Express OpenAI chat server (server.js)
2const express = require('express');
3const OpenAI = require('openai');
4
5const app = express();
6app.use(express.json());
7
8const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
9
10const SYSTEM_PROMPT = 'You are a helpful assistant. Be accurate and concise.';
11
12app.post('/chat', async (req, res) => {
13  try {
14    const { messages } = req.body;
15    if (!messages || !Array.isArray(messages)) {
16      return res.status(400).json({ error: 'messages array required' });
17    }
18
19    const response = await client.chat.completions.create({
20      model: 'gpt-4o',
21      messages: [
22        { role: 'system', content: SYSTEM_PROMPT },
23        ...messages
24      ],
25      max_tokens: 1000,
26      temperature: 0.7
27    });
28
29    res.json({
30      content: response.choices[0].message.content,
31      usage: response.usage,
32      model: response.model
33    });
34  } catch (err) {
35    if (err.status === 429) {
36      return res.status(429).json({ error: 'Rate limit exceeded. Try again shortly.' });
37    }
38    if (err.status === 400 && err.code === 'context_length_exceeded') {
39      return res.status(400).json({ error: 'Conversation too long. Start a new chat.' });
40    }
41    console.error('OpenAI error:', err.message);
42    res.status(500).json({ error: 'AI service error' });
43  }
44});
45
46app.listen(3000, '0.0.0.0', () => console.log('Chat API running on port 3000'));

1// Node.js — Streaming chat endpoint (add to server.js)
2app.post('/chat/stream', async (req, res) => {
3  const { messages } = req.body;
4  if (!messages || !Array.isArray(messages)) {
5    return res.status(400).json({ error: 'messages array required' });
6  }
7
8  res.setHeader('Content-Type', 'text/event-stream');
9  res.setHeader('Cache-Control', 'no-cache');
10  res.setHeader('Connection', 'keep-alive');
11  res.flushHeaders();
12
13  try {
14    const stream = await client.chat.completions.create({
15      model: 'gpt-4o',
16      messages: [
17        { role: 'system', content: SYSTEM_PROMPT },
18        ...messages
19      ],
20      max_tokens: 1000,
21      stream: true
22    });
23
24    for await (const chunk of stream) {
25      const delta = chunk.choices[0]?.delta?.content;
26      if (delta) {
27        res.write(`data: ${JSON.stringify({ content: delta })}\n\n`);
28      }
29    }
30
31    res.write('data: [DONE]\n\n');
32    res.end();
33  } catch (err) {
34    res.write(`data: ${JSON.stringify({ error: err.message })}\n\n`);
35    res.end();
36  }
37});

1# Python — Flask OpenAI server with streaming (app.py)
2import os
3import json
4from flask import Flask, request, jsonify, Response, stream_with_context
5from openai import OpenAI
6
7app = Flask(__name__)
8client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
9
10SYSTEM_PROMPT = "You are a helpful assistant. Be accurate and concise."
11
12@app.route("/chat", methods=["POST"])
13def chat():
14    data = request.get_json()
15    messages = data.get("messages", [])
16    if not messages:
17        return jsonify({"error": "messages array required"}), 400
18
19    response = client.chat.completions.create(
20        model="gpt-4o",
21        messages=[{"role": "system", "content": SYSTEM_PROMPT}] + messages,
22        max_tokens=1000,
23        temperature=0.7
24    )
25    return jsonify({
26        "content": response.choices[0].message.content,
27        "usage": response.usage.model_dump()
28    })
29
30@app.route("/chat/stream", methods=["POST"])
31def chat_stream():
32    data = request.get_json()
33    messages = data.get("messages", [])
34
35    def generate():
36        stream = client.chat.completions.create(
37            model="gpt-4o",
38            messages=[{"role": "system", "content": SYSTEM_PROMPT}] + messages,
39            max_tokens=1000,
40            stream=True
41        )
42        for chunk in stream:
43            delta = chunk.choices[0].delta.content
44            if delta:
45                yield f"data: {json.dumps({'content': delta})}\n\n"
46        yield "data: [DONE]\n\n"
47
48    return Response(stream_with_context(generate()),
49                    mimetype="text/event-stream")
50
51if __name__ == "__main__":
52    app.run(host="0.0.0.0", port=3000)