Working with OpenAI API's

 

ChatGPT API Overview

The ChatGPT API allows developers to integrate OpenAI’s Generative AI capabilities into their own applications, enabling text generation, conversation automation, and more.

---

1. How ChatGPT API Works

✔ Provides access to GPT models, including GPT-4 and earlier versions.
✔ Supports fine-tuning for domain-specific applications.
✔ Offers retrieval-augmented generation (RAG) when combined with vector databases like Pinecone or FAISS.

---

2. Getting Started with ChatGPT API

Step 1: Sign Up & API Key

📌 Register on OpenAI → OpenAI API
📌 Get API Key → Generate API key from OpenAI's developer platform.

Step 2: Install OpenAI Library

pip install openai

Step 3: Basic API Call

import openai

# Define API key
openai.api_key = "YOUR_OPENAI_API_KEY"

# Send request to ChatGPT
response = openai.ChatCompletion.create(
    model="gpt-4",
    messages=[{"role": "user", "content": "Tell me about Generative AI"}]
)

# Print the AI's response
print(response["choices"][0]["message"]["content"])

---

3. Key Features

✅ Supports multiple models → GPT-4, GPT-3.5, older versions.
✅ Fine-tuning capabilities → Customizable responses.
✅ Token-based pricing → Charged per 1,000 tokens used.

📄 Official Documentation

🔗 OpenAI ChatGPT API Docs

Comparison of AI APIs: ChatGPT vs. Claude vs. Gemini vs. LLaMA

Different AI models offer unique features tailored for text generation, reasoning, and multi-modal processing. Below is a detailed comparison of OpenAI's ChatGPT API, Anthropic's Claude API, Google Gemini API, and Meta's LLaMA API.

---

1. ChatGPT API (OpenAI)

🔹 Model Architecture → Decoder-Only Transformer
🔹 Latest Model → GPT-4-turbo
🔹 Best For → Conversational AI, code generation, content creation

Key Features

✅ Multi-Turn Memory → Maintains conversation context.
✅ Supports Fine-Tuning → Customizable AI behavior.
✅ Web Browsing (GPT-4-Turbo) → Retrieves up-to-date information.

📌 Official Docs → ChatGPT API

---

2. Claude API (Anthropic)

🔹 Model Architecture → Decoder-Only Transformer
🔹 Latest Model → Claude 3
🔹 Best For → AI-powered reasoning, safety-focused applications

Key Features

✅ Strong AI Safety Measures → Designed for responsible AI usage.
✅ Handles Long Contexts → Supports 200K+ token input sizes.
✅ Enhanced Transparency → More predictable responses.

📌 Official Docs → Claude API

---

3. Gemini API (Google)

🔹 Model Architecture → Multi-Modal Transformer
🔹 Latest Model → Gemini 1.5
🔹 Best For → Multi-modal AI (text, images, audio, video)

Key Features

✅ Multi-Modal AI → Processes text + images + audio + video.
✅ Scalable Deployment → Integrated with Google Cloud Vertex AI.
✅ Supports Advanced RAG → Optimized for retrieval-augmented generation.

📌 Official Docs → Gemini API

---

4. LLaMA API (Meta)

🔹 Model Architecture → Decoder-Only Transformer (Open-Source)
🔹 Latest Model → LLaMA 3
🔹 Best For → Open-source AI research, fine-tuning experiments

Key Features

✅ Open-Source Accessibility → Freely available for customization.
✅ Efficient Fine-Tuning → Optimized for domain-specific applications.
✅ Supports Local Deployment → Can run offline using Hugging Face or Replicate.

📌 Official Docs → LLaMA Models on Hugging Face

---

5. Key Differences: ChatGPT vs. Claude vs. Gemini vs. LLaMA

Feature	ChatGPT (OpenAI)	Claude (Anthropic)	Gemini (Google)	LLaMA (Meta)
Model Type	Proprietary	Proprietary	Proprietary	Open-Source
Multi-Turn Memory	✅ Yes	✅ Yes	✅ Yes	❌ Limited
Fine-Tuning Support	✅ Yes	❌ No	✅ Yes	✅ Yes
Multi-Modal AI (Images, Audio, Video)	❌ No	❌ No	✅ Yes	❌ No
Best Use Case	Chatbots & content generation	AI safety & long-context tasks	Multi-modal AI & RAG applications	Open-source fine-tuning

---

Which API Should You Choose?

✔ Use ChatGPT if → You need AI-powered conversations, coding assistance, or content generation.
✔ Use Claude if → You require long-context understanding and AI safety.
✔ Use Gemini if → You need multi-modal AI for images, video, and retrieval tasks.
✔ Use LLaMA if → You want full control of AI models and fine-tuning flexibility.

Different API Endpoints from OpenAI

OpenAI provides various API endpoints to access different AI models and functionalities. These endpoints allow developers to integrate text, image, code, and speech generation into applications.

---

1. ChatGPT API (Conversational AI)

🔹 Endpoint: https://api.openai.com/v1/chat/completions
🔹 Models: gpt-4, gpt-4-turbo, gpt-3.5-turbo
🔹 Use Case: AI-powered chatbots, interactive assistants, dialogue systems

Example Usage:

import openai

openai.api_key = "YOUR_API_KEY"

response = openai.ChatCompletion.create(
    model="gpt-4",
    messages=[{"role": "user", "content": "Tell me about Generative AI"}]
)

print(response["choices"][0]["message"]["content"])

---

2. Text Completion API

🔹 Endpoint: https://api.openai.com/v1/completions
🔹 Models: davinci, curie, babbage, ada
🔹 Use Case: AI text generation, autocomplete systems

Example Usage:

response = openai.Completion.create(
    model="text-davinci-003",
    prompt="Write a short story about AI in the future.",
    max_tokens=200
)
print(response["choices"][0]["text"])

---

3. DALL·E API (Image Generation)

🔹 Endpoint: https://api.openai.com/v1/images/generations
🔹 Models: dall-e, dall-e-2, dall-e-3
🔹 Use Case: AI-powered image creation

Example Usage:

response = openai.Image.create(
    model="dall-e-3",
    prompt="A futuristic cityscape with flying cars",
    n=1,
    size="1024x1024"
)
print(response["data"][0]["url"])

---

4. Code Completion API (Codex)

🔹 Endpoint: https://api.openai.com/v1/completions
🔹 Models: code-davinci-002
🔹 Use Case: AI-assisted coding (similar to GitHub Copilot)

---

5. Speech-to-Text API (Whisper)

🔹 Endpoint: https://api.openai.com/v1/audio/transcriptions
🔹 Models: whisper-1
🔹 Use Case: AI-powered speech-to-text transcription

Example Usage:

response = openai.Audio.transcriptions.create(
    model="whisper-1",
    file=open("audio.mp3", "rb"),
    language="en"
)
print(response["text"])

---

6. Text-to-Speech API (TTS)

🔹 Endpoint: https://api.openai.com/v1/audio/speech
🔹 Models: tts-1
🔹 Use Case: AI-generated voice synthesis

Example Usage:

response = openai.Audio.speech.create(
    model="tts-1",
    input="Hello! How can I assist you today?",
    voice="alloy"
)
print(response["data"])

---

7. Chat Completion API (/v1/chat/completions)

🔹 Model Type: Designed for multi-turn conversational AI
🔹 How It Works: Takes structured chat history (messages list) and maintains context across exchanges
🔹 Used in: Chatbots, interactive assistants, dialogue systems

✅ Best for → AI conversations with memory (e.g., ChatGPT)
✅ Supports roles: user, assistant, system

Example Usage:

response = openai.ChatCompletion.create(
    model="gpt-4",
    messages=[{"role": "user", "content": "Tell me about Generative AI"}]
)
print(response["choices"][0]["message"]["content"])

---

3. Key Differences: Text Completion vs. Chat Completion

Feature	Text Completion API	Chat Completion API
Use Case	Text generation (structured content)	Conversational AI (chatbots)
Context Retention	❌ No memory	✅ Maintains conversation history
Prompt Format	Simple text prompt	List of messages with roles (user, assistant, system)
Best For	Essays, autocomplete, summarization	Interactive AI assistants, dialogue systems

---

## Basic Chat Completion request from OpenAI
chat_response = openai.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=message,
    max_tokens=200,
    temperature=0.5,
    n=1,
    stop=None,
    frequency_penalty=0,
    presence_penalty=0)

The three main roles in the messages list are:

• System: This instruction sets the overall behaviour of the assistant.
• User: The user role represents the end user using the chatbot. 
• Assistant: The assistant role represents the chatbot.

While working with the Chat Completions APIs, you need to pay attention to the following parameters, as mentioned in the documentation:

• model: The GPT version and model you want to use
• max_tokens: Refers to the maximum number of tokens to be generated in the model’s response
• temperature: The sampling temperature is a number between 0 (most certain/deterministic) and 1 (most random) and defaults to 0; signifies the randomness in choosing the next tokens
• n: The number of chat completion choices to generate for each input message
• stop: Up to 4 sequences where the API will stop generating further tokens; the returned text will not contain the stop sequence
• frequency_penalty and presence_penalty: These are used to reduce the likelihofod of sampling repetitive sequences of tokens. The recommended values for the penalty coefficients are approximately 0.1–1 if the aim is to just reduce repetitive tokens in the output response. If the aim is to strongly suppress repetition, one can increase the coefficients up to 2, but this results in decreased sample quality.

• These additional parameters are given below:

  • response_format: This parameter specifies the format in which the model should give the output response. For example, the setting { "type": "json_object" } enables the JSON mode, which guarantees that the message the model generates is in the valid JSON format.
  • top_p: The top_p parameter is a sampling technique that serves as an alternative to temperature, where only the tokens with the top_p probability mass are considered. For a top_p value of 0.1, only the tokens with the top 10% probability mass will be considered. 
  • seed: The seed parameter ensures the model provides a deterministic output; repeated requests with the same seed value will return the same results.  The seed parameter takes in integer values, such as 123 (any integer value). These values serve as the context to keep the outputs consistent provided other parameters such as temperature and model are also kept the same across the requests. 

  NOTE: The seed feature is in the beta phase and is currently available only in gpt-4-1106-preview and gpt-3.5-turbo-1106 models.

  • logprobs: This parameter returns the log probabilities of the output tokens. If this parameter is set to true, the model returns the log probabilities of each output token in the content key of the output. The log probabilities of output tokens indicate the likelihood of each token occurring in the sequence given the context. In simple terms, a logprob is log(p), where p is the probability of a token occurring at a specific position based on the previous tokens in the context. 

  Higher log probabilities suggest a higher likelihood of the token matching in that context. This allows users to gauge the model's confidence in its output or explore alternative responses that the model considered. Logprob can be any negative number or 0.0, and. 0.0 corresponds to 100% probability.

  
  NOTE: This option is available in all the models except the gpt-4-vision-preview model.

  • top_logprobs: This is an integer between 0 and 5, specifying the number of the most likely tokens to return at each token position, each with an associated log probability. logprobs must be set to true if this parameter is used. 

Understanding the ChatGPT API Message Roles & Parameters

When making a request to OpenAI's ChatGPT API, you use the messages list, which defines a structured conversation flow. This list includes three main roles:

✅ System → Provides initial instructions, setting behavior for the AI.
✅ User → Represents the human asking questions or providing input.
✅ Assistant → Represents the AI's responses within the conversation.

Additionally, various parameters like model, max_tokens, temperature, and n control how the AI behaves. Below is a complete breakdown of message roles and parameters, along with a robust example covering all concepts.

---

1. Understanding Message Roles (messages list)

🔹 System Role ("role": "system")

✅ Provides global instructions to guide the AI’s behavior.
✅ Defines tone, style, and constraints for responses.
✅ Example instructions:

{"role": "system", "content": "You are an AI assistant that provides professional, technical advice on AI and machine learning. Keep responses concise but informative."}

Use Case: Setting AI's role and behavior.

---

🔹 User Role ("role": "user")

✅ Represents the actual user interacting with the AI.
✅ Provides input in the form of questions, prompts, or requests.
✅ Example:

{"role": "user", "content": "Can you explain transformers in AI?"}

Use Case: Initiating a conversation with the AI.

---

🔹 Assistant Role ("role": "assistant")

✅ Represents the AI's response to the user’s message.
✅ Used to provide answers, generate text, or guide discussions.
✅ Example:

{"role": "assistant", "content": "Sure! Transformers are deep learning models that use self-attention to process sequences efficiently..."}

Use Case: AI-generated replies.

---

2. Parameters in ChatGPT API Requests

Parameter	Description	Example Value
model	Specifies AI model to use (gpt-4, gpt-3.5-turbo).	"model": "gpt-4"
messages	List of conversation messages (roles: system, user, assistant).	"messages": [...]
temperature	Controls randomness (lower = deterministic, higher = creative).	"temperature": 0.7
max_tokens	Limits response length (higher = longer responses).	"max_tokens": 500
top_p	Nucleus sampling (alternative to temperature).	"top_p": 0.9
n	Number of response variations returned.	"n": 1
stop	Allows setting stop words to limit AI response length.	"stop": ["End"]
presence_penalty	Encourages AI to mention new topics.	"presence_penalty": 0.3
frequency_penalty	Reduces repetitive words in responses.	"frequency_penalty": 0.5

---

3. Robust Example Covering All Concepts

Here’s a complete API request, demonstrating roles (system, user, assistant) and key parameters (model, temperature, max_tokens, n, etc.):

import openai

# Define API key
openai.api_key = "YOUR_OPENAI_API_KEY"

# Define messages list with structured roles
messages = [
    {"role": "system", "content": "You are an AI assistant specializing in Generative AI. Keep responses professional and fact-based."},
    {"role": "user", "content": "Explain transformers in AI."},
    {"role": "assistant", "content": "Transformers are deep learning models that use self-attention to efficiently process sequences. They power modern AI like GPT, BERT, and T5."},
    {"role": "user", "content": "How does multi-head attention work?"}
]

# Make API request
response = openai.ChatCompletion.create(
    model="gpt-4",
    messages=messages,
    temperature=0.7,
    max_tokens=200,
    top_p=0.9,
    n=1,
    presence_penalty=0.3,
    frequency_penalty=0.5
)

# Print AI response
print(response["choices"][0]["message"]["content"])

---

4. Which Parameters Should You Use?

✔ Set temperature low (0.2-0.5) → For factual accuracy in technical responses.
✔ Set temperature high (0.7-1.0) → If you need creative storytelling or brainstorming.
✔ Use max_tokens carefully → To limit response length in UI-based apps.
✔ Adjust presence_penalty and frequency_penalty → To reduce repetition or encourage diverse answers.

Complete Explanation of Multi-Turn Conversations with the Chat Completions API

Multi-turn conversations allow AI to remember context across multiple exchanges, making interactions feel natural and dynamic. When using OpenAI’s Chat Completions API, maintaining conversation history is crucial for context-aware responses. Let’s break it down completely.

---

1. What Are Multi-Turn Conversations?

A single-turn conversation consists of one prompt and one AI response. However, real-world applications require continuous dialogues where AI remembers previous interactions.

To achieve this: ✔ Every conversation stores a list of messages → This list maintains history.
✔ Each new user message is appended to the list → AI sees prior exchanges.
✔ Context persists throughout multiple turns → AI generates more meaningful responses.

Example of Single-Turn vs. Multi-Turn:

# Single-turn request (AI doesn't remember past exchanges)
{"messages": [{"role": "user", "content": "Tell me about Generative AI"}]}

# Multi-turn request (AI remembers previous messages)
{"messages": [
    {"role": "system", "content": "You are an AI specializing in AI and machine learning."},
    {"role": "user", "content": "Explain Generative AI."},
    {"role": "assistant", "content": "Generative AI creates new content, including text, images, and code."},
    {"role": "user", "content": "How does GPT differ from BERT?"}
]}

---

2. Structured Roles in Multi-Turn Conversations

Each API request consists of three roles:
✅ System ("role": "system") → Defines AI’s behavior.
✅ User ("role": "user") → Represents the human interacting with AI.
✅ Assistant ("role": "assistant") → Stores AI-generated responses.

By structuring the messages list properly, AI remembers previous exchanges and generates context-aware responses.

---

3. Example Code for Multi-Turn Conversations

Let’s build a multi-turn chatbot where AI remembers previous exchanges.

import openai

# Define API key
openai.api_key = "YOUR_OPENAI_API_KEY"

# Maintain conversation history
messages = [
    {"role": "system", "content": "You are an AI assistant specializing in AI and machine learning."},
    {"role": "user", "content": "Explain generative AI."},
    {"role": "assistant", "content": "Generative AI refers to models that create new content, including text, images, and code."},
    {"role": "user", "content": "How does GPT differ from BERT?"}
]

# API request
response = openai.ChatCompletion.create(
    model="gpt-4",
    messages=messages,  # Full conversation history
    temperature=0.7,
    max_tokens=200
)

# Append AI response to conversation history
messages.append({"role": "assistant", "content": response["choices"][0]["message"]["content"]})

# Print AI response
print(response["choices"][0]["message"]["content"])

✔ Conversation history is maintained by appending new exchanges to messages.
✔ AI sees past interactions, leading to better contextual answers.

---

4. Managing Long Conversations

As conversations grow longer, token usage increases. Best practices:
✔ Keep only recent exchanges (limit history length).
✔ Use a rolling window → Store last 10-15 exchanges, removing old ones.
✔ Summarize past discussions into a single message.

Differences Between GPT-3, GPT-3.5, and GPT-4

OpenAI's GPT series has evolved significantly, improving language understanding, reasoning, efficiency, and creativity. Below is a comparison of GPT-3, GPT-3.5, and GPT-4, explaining their advancements.

---

1. Overview of Each GPT Version

GPT-3 (Released: 2020)

✅ 175 billion parameters → First large-scale AI with advanced text generation.
✅ Few-shot learning → Capable of answering with minimal examples.
✅ Used for: Basic chatbots, content writing, code generation.
✅ Limitations: Struggles with logical reasoning & factual accuracy.

📄 Key Research Paper:

📌 Brown et al. (2020) – "Language Models Are Few-Shot Learners"
🔗 Link

---

GPT-3.5 (Released: 2022)

✅ Improved efficiency → Faster processing & lower latency.
✅ Refined conversational AI → More coherent and context-aware responses.
✅ Supports Reinforcement Learning from Human Feedback (RLHF) → AI aligns better with human preferences.
✅ Limitations: Still weaker in long-form reasoning compared to GPT-4.

---

GPT-4 (Released: 2023)

✅ Massively improved reasoning → Handles complex queries with enhanced logical accuracy.
✅ Better multi-turn conversations → Maintains longer chat history.
✅ Supports multi-modal inputs → Accepts text + images in GPT-4V (Vision).
✅ More diverse responses → Less biased and factually stronger than GPT-3.5.
✅ Limitations: Higher computational cost, slower than GPT-3.5 in casual tasks.

📄 Key Research Paper:

📌 OpenAI – "GPT-4 Technical Report"
🔗 Link

---

2. Key Differences in Model Capabilities

Feature	GPT-3	GPT-3.5	GPT-4
Reasoning Ability	Basic	Moderate	Advanced
Context Retention	Limited	Improved	Stronger memory
Multi-Turn Conversations	Struggles	Decent	Highly coherent
Multi-Modal Input (Text + Images)	❌ No	❌ No	✅ Yes (GPT-4V)
Bias & Ethical Improvements	Moderate	Better	Much improved
Best Use Cases	Writing, coding	Chatbots, creative AI	Advanced reasoning, research

---

3. Which Model Should You Use?

✔ Use GPT-3.5 → If you need fast AI responses for chatbots & casual applications.
✔ Use GPT-4 → If you need better accuracy, advanced reasoning, and multi-modal capabilities.