1

pip install openai python-dotenv

1

OPENAI_API_KEY=sk-...

1

pip install anthropic python-dotenv

1

ANTHROPIC_API_KEY=sk-ant-...here

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

import os
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "You are a helpful programming tutor for students."},
        {"role": "user", "content": "Explain recursion in Python with a simple example."}
    ],
    max_tokens=500,
    temperature=0.7
)

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

import os
from anthropic import Anthropic
from dotenv import load_dotenv

load_dotenv()
client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=500,
    system="You are a helpful programming tutor for students.",
    messages=[
        {"role": "user", "content": "Explain recursion in Python with a simple example."}
    ]
)

print(response.content[0].text)

1
2
3
4
5
6
7
8
9

stream = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Write a 500-word essay on AI agents."}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

1
2
3
4
5
6
7

with client.messages.stream(
    model="claude-sonnet-4-20250514",
    max_tokens=500,
    messages=[{"role": "user", "content": "Write a 500-word essay on AI agents."}]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

def stream_chat_openai(messages, model="gpt-4o-mini"):
    """Stream a chat response with proper formatting."""
    stream = client.chat.completions.create(
        model=model,
        messages=messages,
        stream=True
    )
    
    full_response = ""
    for chunk in stream:
        if chunk.choices[0].delta.content:
            token = chunk.choices[0].delta.content
            print(token, end="", flush=True)
            full_response += token
    
    return full_response

# Usage
messages = [
    {"role": "system", "content": "You are a helpful tutor."},
    {"role": "user", "content": "What is dynamic programming?"}
]
response = stream_chat_openai(messages)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

import json

def get_weather(city: str) -> str:
    """Get current weather for a city (mock implementation)"""
    return f"The weather in {city} is 72°F and sunny."

def calculate_tip(bill: float, percentage: float = 15.0) -> str:
    """Calculate tip amount."""
    tip = bill * (percentage / 100)
    return f"Tip: ${tip:.2f} (Total: ${bill + tip:.2f})"

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get current weather for a city",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "City name"}
                },
                "required": ["city"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "calculate_tip",
            "description": "Calculate tip for a restaurant bill",
            "parameters": {
                "type": "object",
                "properties": {
                    "bill": {"type": "number", "description": "Bill amount in dollars"},
                    "percentage": {"type": "number", "description": "Tip percentage (default 15%)"}
                },
                "required": ["bill"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "What's the weather in Tokyo and what's the tip on a $45 bill?"}],
    tools=tools
)

# Handle tool calls
if response.choices[0].message.tool_calls:
    for tool_call in response.choices[0].message.tool_calls:
        args = json.loads(tool_call.function.arguments)
        if tool_call.function.name == "get_weather":
            result = get_weather(**args)
        elif tool_call.function.name == "calculate_tip":
            result = calculate_tip(**args)
        print(f"Tool: {tool_call.function.name}({args}) → {result}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

tools = [
    {
        "name": "get_weather",
        "description": "Get current weather for a city",
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {"type": "string", "description": "City name"}
            },
            "required": ["city"]
        }
    }
]

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=500,
    messages=[{"role": "user", "content": "What's the weather in Tokyo?"}],
    tools=tools
)

# Handle tool use
if response.stop_reason == "tool_use":
    for block in response.content:
        if block.type == "tool_use":
            result = get_weather(block.input["city"])
            print(f"Tool: {block.name} → {result}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

import base64

def encode_image(image_path):
    with open(image_path, "rb") as f:
        return base64.b64encode(f.read()).decode("utf-8")

base64_image = encode_image("diagram.png")

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "You are a helpful tutor."},
        {"role": "user", "content": [
            {"type": "text", "text": "Explain this diagram to a first-year CS student."},
            {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{base64_image}"}}
        ]}
    ],
    max_tokens=500
)

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

import base64

with open("diagram.png", "rb") as f:
    base64_image = base64.b64encode(f.read()).decode("utf-8")

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=500,
    messages=[{"role": "user", "content": [
        {"type": "text", "text": "Explain this diagram to a first-year CS student."},
        {"type": "image", "source": {
            "type": "base64",
            "media_type": "image/png",
            "data": base64_image
        }}
    ]}]
)

print(response.content[0].text)

1
2
3
4
5
6
7

response = client.embeddings.create(
    input=["Python is a programming language", "JavaScript is used for web development"],
    model="text-embedding-3-small"
)

vectors = [item.embedding for item in response.data]
print(f"Vector dimension: {len(vectors[0])}")  # 1536 for text-embedding-3-small

1
2
3

# Anthropic doesn't have a separate embedding endpoint
# Use their messages API with a custom prompt for similarity tasks
# Or use OpenAI's embedding API alongside Anthropic

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

import numpy as np
from openai import OpenAI

client = OpenAI()

def get_embedding(text):
    response = client.embeddings.create(input=[text], model="text-embedding-3-small")
    return response.data[0].embedding

def cosine_similarity(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

# Index your documents
documents = [
    "Python is a high-level programming language",
    "JavaScript runs in web browsers",
    "Machine learning uses statistical models",
    "Databases store structured data",
    "APIs enable communication between software"
]

index = [(doc, get_embedding(doc)) for doc in documents]

# Search
query = "How do websites work?"
query_vec = get_embedding(query)

results = sorted(
    [(doc, cosine_similarity(query_vec, vec)) for doc, vec in index],
    key=lambda x: -x[1]
)

for doc, score in results[:3]:
    print(f"  {score:.3f} — {doc}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

import time
import logging
from openai import OpenAI, RateLimitError, APIError, APITimeoutError, AuthenticationError

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def safe_api_call_openai(messages, model="gpt-4o-mini", max_retries=3):
    """Make an API call with comprehensive error handling."""
    for attempt in range(max_retries):
        try:
            response = client.chat.completions.create(
                model=model,
                messages=messages,
                max_tokens=500
            )
            return response.choices[0].message.content
            
        except AuthenticationError:
            logger.error("Invalid API key. Check your .env file.")
            raise  # Don't retry — this won't fix itself
            
        except RateLimitError as e:
            wait_time = 2 ** attempt  # Exponential backoff: 1s, 2s, 4s
            logger.warning(f"Rate limited. Waiting {wait_time}s... (attempt {attempt+1}/{max_retries})")
            if attempt < max_retries - 1:
                time.sleep(wait_time)
            else:
                raise
                
        except APITimeoutError:
            logger.warning(f"Request timed out. Retrying... (attempt {attempt+1}/{max_retries})")
            if attempt < max_retries - 1:
                time.sleep(1)
            else:
                raise
                
        except APIError as e:
            logger.error(f"API error: {e}")
            if e.code in ["server_error", "service_unavailable"] and attempt < max_retries - 1:
                time.sleep(2 ** attempt)
            else:
                raise
                
        except Exception as e:
            logger.error(f"Unexpected error: {e}")
            raise

    return None  # All retries exhausted

# Usage
try:
    response = safe_api_call_openai([
        {"role": "user", "content": "Explain quicksort"}
    ])
    print(response)
except Exception as e:
    print(f"Failed after retries: {e}")

1
2
3
4
5
6

# Cost-effective pattern
response = client.chat.completions.create(
    model="gpt-4o-mini",  # Use cheaper model
    messages=[{"role": "user", "content": "Short answer please."}],
    max_tokens=100  # Limit output length
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

import os
from openai import OpenAI

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

SYSTEM_PROMPT = """You are a study buddy for computer science students.
You help with: explaining concepts, debugging code, reviewing assignments,
creating study plans, and explaining exam topics.
Be concise, encouraging, and always provide code examples when relevant."""

def chat(user_message: str, history: list = None) -> str:
    messages = [{"role": "system", "content": SYSTEM_PROMPT}]
    if history:
        messages.extend(history)
    messages.append({"role": "user", "content": user_message})
    
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=messages,
        max_tokens=500
    )
    return response.choices[0].message.content

# Interactive loop
print("Study Buddy: Hi! I'm your CS study buddy. Ask me anything (type 'quit' to exit).")
history = []
while True:
    user_input = input("\nYou: ").strip()
    if user_input.lower() in ['quit', 'exit']:
        break
    response = chat(user_input, history)
    print(f"\nBuddy: {response}")
    history.extend([
        {"role": "user", "content": user_input},
        {"role": "assistant", "content": response}
    ])
    # Keep history manageable (last 10 exchanges)
    if len(history) > 20:
        history = history[-20:]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

def review_code(code: str, language: str = "Python") -> str:
    """Submit code for AI review."""
    prompt = f"""Review this {language} code for:
1. Bugs and potential errors
2. Code style and readability
3. Performance improvements
4. Security concerns
5. Best practices

Code:
```{language.lower()}
{code}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

### Project 3: Research Paper Summarizer

```python
def summarize_paper(text: str) -> dict:
    """Summarize a research paper into key sections."""
    prompt = f"""Analyze this research paper and provide:
1. **Main Contribution** (2-3 sentences)
2. **Key Methods** (bullet points)
3. **Main Findings** (bullet points)
4. **Limitations** (bullet points)
5. **Future Work** (bullet points)
6. **Relevance to Students** (1-2 sentences)

Paper:
{text[:8000]}  # Truncate to fit context window
"""
    
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=1000
    )
    return response.choices[0].message.content

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

def writing_coach(essay: str, assignment_type: str = "essay") -> str:
    """Get feedback on writing from an AI coach."""
    prompt = f"""You are a writing coach for university students.
Review this {assignment_type} and provide feedback on:

1. **Thesis/Argument** — Is the main argument clear and well-supported?
2. **Structure** — Is the organization logical and effective?
3. **Evidence** — Are claims supported with evidence?
4. **Clarity** — Is the writing clear and concise?
5. **Grammar** — Any grammatical issues?
6. **Suggestions** — 3 specific improvements

Be constructive and encouraging. Point out strengths too.

Essay:
{essay}
"""
    
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=1000
    )
    return response.choices[0].message.content