Tutorial ChatGPT API: prima ta aplicatie AI

Vrei sa construiesti cu ChatGPT dar nu stii de unde sa incepi? Acest ghid pentru incepatori te duce de la zero la prima ta aplicatie AI functionala.

Ce vei invata

Journey Map:
1. Get API Key         → 5 minutes
2. First API Call      → 10 minutes
3. Build Simple Chat   → 20 minutes
4. Add Features        → 30 minutes
   ─────────────────────────────
   Total: ~1 hour to working app

Pasul 1: Obtine cheia API

Creeaza un cont OpenAI:

Mergi la https://platform.openai.com
Inregistreaza-te cu email sau Google
Verifica-ti email-ul

Obtine cheia API:

Click pe profilul tau -> "API keys"
Click pe "Create new secret key"
Da-i un nume, de exemplu "my-first-app"
Copiaza cheia imediat (nu o vei mai vedea!)

# Your key looks like this:
sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
 
# Store it safely - NEVER share or commit to git!

Adauga o metoda de plata:

Nivelul gratuit are limite. Adauga o metoda de plata pentru acces mai bun:

Mergi la Settings -> Billing
Adauga un card
Seteaza limite de utilizare pentru a evita surprizele

Pasul 2: Configureaza-ti mediul de lucru

Optiunea A: Python (recomandat pentru incepatori)

# Install Python if needed: https://python.org
 
# Create project folder
mkdir my-first-ai-app
cd my-first-ai-app
 
# Create virtual environment
python -m venv venv
source venv/bin/activate  # Windows: venv\Scripts\activate
 
# Install OpenAI library
pip install openai python-dotenv

Creeaza fisierul .env pentru cheia API:

# .env file (DON'T commit this to git!)
OPENAI_API_KEY=sk-your-key-here

Optiunea B: Node.js

mkdir my-first-ai-app
cd my-first-ai-app
npm init -y
npm install openai dotenv

// .env file
OPENAI_API_KEY=sk-your-key-here

Pasul 3: Primul tau apel API

Python - Hello World:

# hello_ai.py
import os
from openai import OpenAI
from dotenv import load_dotenv
 
# Load API key from .env file
load_dotenv()
 
# Create client
client = OpenAI()
 
# Make your first request!
response = client.chat.completions.create(
    model="gpt-4o-mini",  # Cheaper model for learning
    messages=[
        {"role": "user", "content": "Say hello and tell me a fun fact!"}
    ]
)
 
# Print the response
print(response.choices[0].message.content)

Ruleaza-l:

python hello_ai.py
# Output: Hello! Here's a fun fact: Honey never spoils...

JavaScript - Hello World:

// hello_ai.js
require('dotenv').config();
const OpenAI = require('openai');
 
const client = new OpenAI();
 
async function main() {
    const response = await client.chat.completions.create({
        model: "gpt-4o-mini",
        messages: [
            { role: "user", content: "Say hello and tell me a fun fact!" }
        ]
    });
 
    console.log(response.choices[0].message.content);
}
 
main();

Pasul 4: Intelegerea API-ului

Array-ul de mesaje:

messages = [
    # System message: Sets AI behavior
    {"role": "system", "content": "You are a helpful coding tutor."},
 
    # User messages: What you ask
    {"role": "user", "content": "What is a variable?"},
 
    # Assistant messages: AI's previous responses
    {"role": "assistant", "content": "A variable is like a labeled box..."},
 
    # Another user message
    {"role": "user", "content": "Can you give me an example?"}
]

Parametri cheie:

response = client.chat.completions.create(
    model="gpt-4o-mini",     # Which AI model to use
    messages=messages,        # Conversation history
    temperature=0.7,          # Creativity (0=focused, 2=creative)
    max_tokens=500,           # Maximum response length
)

Modele disponibile:

| Model | Recomandat pentru | Cost | |-------|-------------------|------| | gpt-4o-mini | Invatare, taskuri simple | $ | | gpt-4o | Taskuri complexe, productie | $$ | | gpt-4-turbo | Documente lungi | $$$ |

Pasul 5: Construieste un chatbot simplu

Chatbot Python:

# chatbot.py
import os
from openai import OpenAI
from dotenv import load_dotenv
 
load_dotenv()
client = OpenAI()
 
def chat():
    print("ChatBot Ready! Type 'quit' to exit.\n")
 
    # Store conversation history
    messages = [
        {"role": "system", "content": "You are a friendly assistant. Keep responses concise."}
    ]
 
    while True:
        # Get user input
        user_input = input("You: ").strip()
 
        if user_input.lower() == 'quit':
            print("Goodbye!")
            break
 
        if not user_input:
            continue
 
        # Add user message to history
        messages.append({"role": "user", "content": user_input})
 
        # Get AI response
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=messages,
            max_tokens=500
        )
 
        # Extract and print response
        ai_message = response.choices[0].message.content
        print(f"\nBot: {ai_message}\n")
 
        # Add AI response to history (for context)
        messages.append({"role": "assistant", "content": ai_message})
 
if __name__ == "__main__":
    chat()

Ruleaza chatbot-ul:

python chatbot.py
 
# ChatBot Ready! Type 'quit' to exit.
#
# You: What's Python?
#
# Bot: Python is a popular programming language known for being
# easy to read and learn...
#
# You: How do I install it?
#
# Bot: You can install Python by visiting python.org...

Pasul 6: Adauga streaming (raspunsuri in timp real)

Streameaza raspunsurile cuvant cu cuvant, ca in ChatGPT:

# streaming_chat.py
import os
from openai import OpenAI
from dotenv import load_dotenv
 
load_dotenv()
client = OpenAI()
 
def stream_chat():
    print("Streaming ChatBot Ready!\n")
 
    messages = [
        {"role": "system", "content": "You are a helpful assistant."}
    ]
 
    while True:
        user_input = input("You: ").strip()
 
        if user_input.lower() == 'quit':
            break
 
        messages.append({"role": "user", "content": user_input})
 
        # Enable streaming
        print("Bot: ", end="", flush=True)
 
        stream = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=messages,
            stream=True  # Enable streaming!
        )
 
        # Collect response as it streams
        full_response = ""
        for chunk in stream:
            if chunk.choices[0].delta.content:
                content = chunk.choices[0].delta.content
                print(content, end="", flush=True)
                full_response += content
 
        print("\n")
        messages.append({"role": "assistant", "content": full_response})
 
if __name__ == "__main__":
    stream_chat()

Pasul 7: Gestioneaza erorile corect

Erori comune si cum sa le tratezi:

import openai
from openai import OpenAI
 
client = OpenAI()
 
def safe_chat(messages):
    try:
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=messages
        )
        return response.choices[0].message.content
 
    except openai.AuthenticationError:
        return "Error: Invalid API key. Check your OPENAI_API_KEY."
 
    except openai.RateLimitError:
        return "Error: Too many requests. Please wait a moment."
 
    except openai.APIConnectionError:
        return "Error: Can't connect to OpenAI. Check your internet."
 
    except openai.BadRequestError as e:
        return f"Error: Bad request - {e.message}"
 
    except Exception as e:
        return f"Unexpected error: {str(e)}"
 
# Usage
messages = [{"role": "user", "content": "Hello!"}]
result = safe_chat(messages)
print(result)

Pasul 8: Monitorizeaza-ti costurile

Urmareste consumul de token-uri:

def chat_with_cost_tracking(messages):
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=messages
    )
 
    # Get token counts
    usage = response.usage
    prompt_tokens = usage.prompt_tokens
    completion_tokens = usage.completion_tokens
    total_tokens = usage.total_tokens
 
    # Calculate cost (gpt-4o-mini prices)
    # $0.15 per 1M input tokens, $0.60 per 1M output tokens
    cost = (prompt_tokens * 0.00000015) + (completion_tokens * 0.0000006)
 
    print(f"Tokens used: {total_tokens} (Cost: ${cost:.6f})")
 
    return response.choices[0].message.content

Proiect complet pentru incepatori: Asistent personal

# assistant.py
import os
from openai import OpenAI
from dotenv import load_dotenv
from datetime import datetime
 
load_dotenv()
client = OpenAI()
 
class PersonalAssistant:
    def __init__(self, name="Assistant"):
        self.name = name
        self.messages = [
            {
                "role": "system",
                "content": f"""You are {name}, a helpful personal assistant.
                Today's date is {datetime.now().strftime('%B %d, %Y')}.
                Be friendly, concise, and helpful."""
            }
        ]
 
    def chat(self, user_message):
        self.messages.append({"role": "user", "content": user_message})
 
        try:
            response = client.chat.completions.create(
                model="gpt-4o-mini",
                messages=self.messages,
                max_tokens=500,
                temperature=0.7
            )
 
            ai_message = response.choices[0].message.content
            self.messages.append({"role": "assistant", "content": ai_message})
 
            return ai_message
 
        except Exception as e:
            return f"Sorry, I encountered an error: {str(e)}"
 
    def clear_history(self):
        """Start fresh conversation"""
        self.messages = self.messages[:1]  # Keep system message
 
def main():
    assistant = PersonalAssistant("Aria")
 
    print(f"🤖 {assistant.name} is ready to help!")
    print("Commands: 'quit' to exit, 'clear' to reset conversation\n")
 
    while True:
        user_input = input("You: ").strip()
 
        if user_input.lower() == 'quit':
            print(f"{assistant.name}: Goodbye! 👋")
            break
        elif user_input.lower() == 'clear':
            assistant.clear_history()
            print(f"{assistant.name}: Conversation cleared! How can I help?\n")
            continue
        elif not user_input:
            continue
 
        response = assistant.chat(user_input)
        print(f"\n{assistant.name}: {response}\n")
 
if __name__ == "__main__":
    main()

Ce urmeaza?

Acum ca ai bazele, exploreaza:

Adauga memorie - Stocheaza conversatiile intr-o baza de date
Construieste o aplicatie web - Foloseste Flask sau FastAPI
Adauga RAG - Lasa bot-ul sa raspunda din documentele tale
Deploy - Pune-ti aplicatia pe internet

Referinta rapida

# Install
pip install openai python-dotenv
 
# Test API key
python -c "from openai import OpenAI; OpenAI().models.list()"
 
# Simple call
from openai import OpenAI
client = OpenAI()
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Hello!"}]
)
print(response.choices[0].message.content)

Ai nevoie de ajutor sa construiesti aplicatii AI?

Trecerea de la tutorial la productie necesita mai mult decat apeluri API. Echipa noastra te poate ajuta cu:

Arhitectura AI pregatita pentru productie
Securitate si conformitate (EU AI Act)
Optimizarea costurilor
Solutii AI personalizate

Obtine ajutor pentru dezvoltare AI

Sistemul tau AI e conform cu EU AI Act? Evaluare gratuita de risc - afla in 2 minute →