The Complete ChatGPT Guide
GPT-4o, API & automation

What is ChatGPT?

ChatGPT is a conversational interface from OpenAI, running on the GPT (Generative Pre-trained Transformer) family of models. It is not just "AI that answers questions" — it is a full platform for writing, analysis, coding, image and voice generation, building apps and automation. Since its launch in November 2022 it has changed how millions of people work around the world.

At the heart of the product is a large language model (LLM) trained on enormous amounts of text and finished with RLHF (Reinforcement Learning from Human Feedback) — a technique that makes it useful, safe and helpful.

GPT-4o vs the o-series models vs GPT-3.5 — what is the difference?

What can you do with ChatGPT?

• Writing: articles, emails, copywriting, scripts, translation, editing
• Code: writing, debug, code review, code explanation, converting programming languages
• Data analysis: Code Interpreter runs Python directly, creates charts and analyzes files
• Images: Built-in DALL-E 3 — generation and editing from text
• Voice: Voice Mode with low latency like a real human conversation
• Research: Real-time Web Search with source Grounding (ChatGPT Plus)
• Automation: Function Calling, Assistants API, multi-step Agents

The roadmap to mastering ChatGPT

The journey from "beginner" to "master" goes through 5 clear stages. Each stage builds on the previous one — don't skip.

Prompt Engineering

Prompt Engineering is the art of phrasing instructions that get the best result out of the model. The difference between a bad prompt and a good one can be the difference between useless output and output that saves hours of work. It is not magic — it is a learnable skill.

Zero-shot vs Few-shot vs Chain-of-Thought

Persona Technique — "Act as..."

One of the most powerful techniques is defining a persona — ask the model to act as an expert in a specific field. This significantly improves the quality, depth and style of the output. Here is a ready-to-use template:

SYSTEM: Act as an expert in [field] with [X] years of experience.
Your style: [professional/friendly/technical].
The user: [audience description].
Output format: [JSON/Markdown/lists].
Language: clear language, technical terms in English.
If you are not sure — say so explicitly. Do not make up information.

Structured Output — JSON Mode

When you need structured output for code processing, there are two approaches: defining response_format: { type: "json_object" } in the API, or usingStructured Outputs — defining a precise JSON Schema the model must comply with. Structured Outputs guarantees 100% compliance with the schema.

from openai import OpenAI
from pydantic import BaseModel

client = OpenAI()

class ArticleAnalysis(BaseModel):
    title: str
    main_topic: str
    sentiment: str  # "positive" | "negative" | "neutral"
    key_points: list[str]
    word_count: int

response = client.beta.chat.completions.parse(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "Analyze the article and provide structured JSON."},
        {"role": "user",   "content": "Article: [article text here]"}
    ],
    response_format=ArticleAnalysis,
)

analysis = response.choices[0].message.parsed
print(f"Topic: {analysis.main_topic}")
print(f"Key points: {analysis.key_points}")

Temperature & Top-p — controlling variety

GPT-4o capabilities

GPT-4o ("omni") is OpenAI's multimodal model — it understands and generates text, images and voice in one continuous conversation. This is a significant leap from earlier models that handled each modality separately with high latency.

Vision — analyzing images and documents

Send any image, screenshot, PDF, diagram or chart — GPT-4o will describe, analyze and answer questions about it. The interface supports URLs and local files (base64). Main uses at work:

• analyzing business charts and graphs — trends, anomalies, comparisons
• reading forms, receipts, invoices and Word/PDF documents
• Debugging UI screenshots — spotting errors in interfaces
• explaining architecture diagrams and ERDs
• translating images with text, scanned documents (OCR)

from openai import OpenAI

client = OpenAI()

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Analyze this chart: what is the overall trend? What anomalies are there?"},
                {
                    "type": "image_url",
                    "image_url": {"url": "https://example.com/chart.png"}
                    # or: "url": f"data:image/jpeg;base64,{base64_image}"
                }
            ]
        }
    ]
)
print(response.choices[0].message.content)

DALL-E 3 — image generation

ChatGPT Plus has built-in access to DALL-E 3. Just ask "create an image of..." — GPT-4o even automatically improves your prompt before sending it to DALL-E. Through the API you can control size, quality and style:

from openai import OpenAI
client = OpenAI()

response = client.images.generate(
    model="dall-e-3",
    prompt="a minimalist logo for an AI company, blue and purple colors, flat design style, white background",
    size="1024x1024",   # 1024x1024 | 1792x1024 | 1024x1792
    quality="hd",       # "standard" | "hd"
    style="vivid",      # "vivid" | "natural"
    n=1
)
print(response.data[0].url)
print(response.data[0].revised_prompt)  # the prompt improved by GPT

Code Interpreter — a built-in Python engine

Code Interpreter (Advanced Data Analysis) runs Python code in real time in an isolated sandbox. Drop in a CSV, Excel or JSON file — and get analysis, charts and insights. It is a hugely valuable tool for data people, analysts and managers.

• statistical analysis: averages, outliers, trends, correlations
• visualization with matplotlib and seaborn — charts and graphs
• file processing: extracting text from PDF, editing Excel, converting formats
• complex calculators: ROI, NPV, currency conversions, financial calculations
• basic NLP analysis: word counts, sentiment, entity extraction

Voice Mode — a human conversation

GPT-4o Voice Mode enables a spoken conversation with sub-second latency — close to a natural human conversation. The model detects intonation, can be interrupted mid-sentence, and includes a variety of built-in voices. Available in ChatGPT Plus via the mobile app. Uses: language practice, one-on-one meetings, preparing speeches.

Memory — memory across conversations

ChatGPT can save facts about you across different conversations and use them in the future. You can manage the memory manually: "Remember that I am a CTO, a Python developer, and working on a SaaS project in healthcare." Memory is available in Plus and Team, and can be turned off via Settings > Personalization > Memory.

Custom GPTs

Custom GPTs let you build a personalized version of ChatGPT with specific instructions, knowledge and capabilities — without writing a single line of code. You can share them publicly in the GPT Store or keep them private for personal or organizational use.

The three components of a Custom GPT

Example: a Custom GPT for a project manager

# Example Instructions — Custom GPT "My Project Manager"

You are a senior project manager with 15 years of experience in Agile, Scrum and Kanban.
Your role is to help plan, track and give feedback on projects.

When a problem or a new project is described, always ask about:
- Timeline and Deadline
- team size and skills
- possible Dependencies and Blockers
- Budget constraints

Always provide:
1. a breakdown into Milestones with dates
2. a list of Risks with Impact and Mitigation
3. measurable KPIs for success

Format: Markdown with clear headers.
Language: clear, professional terms in English.
Do not provide time estimates without information about team size.

ChatGPT API for developers

The OpenAI API lets you integrate GPT capabilities directly into your applications. It is the most widely used AI API in the world — with excellent documentation, SDKs for Python, JavaScript, Go, Java and more, and a huge community.

Quick start — Python SDK

# Installation
pip install openai

# Set the API Key (recommended as an environment variable)
export OPENAI_API_KEY="sk-proj-..."  # Linux/Mac
# or in a .env file with python-dotenv

from openai import OpenAI

# the SDK reads OPENAI_API_KEY automatically
client = OpenAI()

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "You are a professional assistant. Always answer clearly."},
        {"role": "user",   "content": "Summarize this document in 3 points: [document text]"}
    ],
    temperature=0.7,
    max_tokens=1000,
    top_p=1.0,
    frequency_penalty=0.0,
    presence_penalty=0.0
)

# read the response
print(response.choices[0].message.content)

# token usage information
print(f"Input tokens:  {response.usage.prompt_tokens}")
print(f"Output tokens: {response.usage.completion_tokens}")
print(f"Total tokens:  {response.usage.total_tokens}")

Function Calling / Tool Use

Function Calling lets the model call predefined functions — GPT decides when which function to call, and returns the arguments in JSON format. This is the basis for building AI Agents that perform actions in the real world.

import json
from openai import OpenAI

client = OpenAI()

# define the tools available to the model
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get weather information for a given city and date",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "City name, e.g.: Tel Aviv, Jerusalem"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "Temperature unit"
                    }
                },
                "required": ["city"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "search_web",
            "description": "Search the web for up-to-date information",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "The search query"}
                },
                "required": ["query"]
            }
        }
    }
]

messages = [{"role": "user", "content": "What's the weather in Tel Aviv today?"}]

response = client.chat.completions.create(
    model="gpt-4o",
    messages=messages,
    tools=tools,
    tool_choice="auto"  # "auto" | "required" | "none"
)

# check if the model wants to call a function
choice = response.choices[0]
if choice.finish_reason == "tool_calls":
    tool_call = choice.message.tool_calls[0]
    args = json.loads(tool_call.function.arguments)
    print(f"Call to: {tool_call.function.name}")
    print(f"Arguments: {args}")
    # here you run the real function and return the result

Streaming — real-time responses

from openai import OpenAI

client = OpenAI()

# Streaming returns chunks in real time — like ChatGPT
with client.chat.completions.stream(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Write a short poem about the Mediterranean Sea"}]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

print()  # a new line at the end

Assistants API + Threads

The Assistants API is for applications that need to manage long conversations, keep history, and use tools — all managed by OpenAI. Suited to chatbots, personal assistants, and Q&A systems.

from openai import OpenAI
client = OpenAI()

# Step 1: create an Assistant (once)
assistant = client.beta.assistants.create(
    name="Task management assistant",
    instructions="You help manage daily tasks. Answer clearly.",
    model="gpt-4o",
    tools=[
        {"type": "code_interpreter"},
        {"type": "file_search"}
    ]
)

# Step 2: create a Thread per conversation
thread = client.beta.threads.create()

# Step 3: add a message to the conversation
client.beta.threads.messages.create(
    thread_id=thread.id,
    role="user",
    content="Prioritize the tasks: writing a report, a meeting with a client, updating the README, code review"
)

# Step 4: run and wait for the result
run = client.beta.threads.runs.create_and_poll(
    thread_id=thread.id,
    assistant_id=assistant.id
)

# Step 5: read the response
if run.status == "completed":
    messages = client.beta.threads.messages.list(thread_id=thread.id)
    print(messages.data[0].content[0].text.value)

Pricing — what does it cost?

5 hands-on projects

Real learning happens through building. Here are 5 projects ranked by difficulty — each with a clear scope, a realistic time, and skills you'll gain.

def run_agent(user_task: str) -> str:
    messages = [
        {"role": "system", "content": "You are an automation agent. You have tools."},
        {"role": "user",   "content": user_task}
    ]

    while True:
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=messages,
            tools=AVAILABLE_TOOLS,
            tool_choice="auto"
        )
        msg = response.choices[0].message
        messages.append(msg)  # save the agent's response

        if msg.tool_calls:
            # run every tool the agent requested
            for tc in msg.tool_calls:
                args = json.loads(tc.function.arguments)
                result = execute_tool(tc.function.name, args)
                messages.append({
                    "role": "tool",
                    "tool_call_id": tc.id,
                    "content": json.dumps(result)
                })
        else:
            # the model is done — no tool_calls
            return msg.content

# Step 1: Indexing — Embedding the documents
def index_documents(chunks: list[str]) -> list:
    response = client.embeddings.create(
        model="text-embedding-3-small",
        input=chunks
    )
    # store in Pinecone / Chroma / pgvector
    return [e.embedding for e in response.data]

# Step 2: RAG Query
def rag_query(question: str) -> str:
    # Embed the question
    q_vec = client.embeddings.create(
        model="text-embedding-3-small",
        input=question
    ).data[0].embedding

    # search for the relevant chunks (top-5)
    results = vector_db.query(vector=q_vec, top_k=5)
    context = "\n\n".join([r["metadata"]["text"] for r in results])

    # GPT answers only from the context
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "role": "system",
                "content": f"Answer only based on the following information. "
                           f"If the answer is not in the information — say 'I don't know'.\n\n{context}"
            },
            {"role": "user", "content": question}
        ]
    )
    return response.choices[0].message.content

Cheat sheet — ChatGPT Cheat Sheet

Everything you need at hand — tables, templates, endpoints and common errors.

Quick model comparison

Ready-to-use Prompt Templates

Main API Endpoints

Common errors and solutions