OpenAI API를 사용하는 GPT-5 Python 빠른 시작 가이드

%env OPENAI_API_KEY=KEY

!pip install openai weave

import os
import weave
from openai import OpenAI

# Initialize Weave
weave.init('gpt-5-tutorial')

# Initialize OpenAI client
client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))

gpt_assistant_prompt = "You are a " + input ("Who should I be, as I answer your prompt?") 
gpt_user_prompt = input ("What do you want me to do?") 

@weave.op()
def generate_with_custom_prompts(assistant_prompt: str, user_prompt: str, reasoning_effort: str = "low") -> dict:
    """Generate text using your custom prompts with GPT-5's Responses API"""
    response = client.responses.create(
        model="gpt-5",
        reasoning={"effort": reasoning_effort},
        input=[
            {
                "role": "developer",
                "content": assistant_prompt
            },
            {
                "role": "user", 
                "content": user_prompt
            }
        ]
    )
    
    return {
        "output_text": response.output_text,
        "assistant_role": assistant_prompt,
        "user_request": user_prompt,
        "reasoning_effort": reasoning_effort
    }

# Use your custom prompts
basic_result = generate_with_custom_prompts(gpt_assistant_prompt, gpt_user_prompt, "medium")
print("Generated response:", basic_result["output_text"])

@weave.op()
def generate_with_reasoning_levels(assistant_prompt: str, user_prompt: str) -> dict:
    """Compare your prompts across different reasoning effort levels"""
    results = {}
    efforts = ["low", "medium", "high"]
    
    for effort in efforts:
        print(f"Generating with {effort} reasoning effort...")
        response = client.responses.create(
            model="gpt-5",
            reasoning={"effort": effort},
            input=[
                {
                    "role": "developer",
                    "content": assistant_prompt
                },
                {
                    "role": "user",
                    "content": user_prompt
                }
            ]
        )
        
        results[effort] = {
            "output": response.output_text,
            "effort_level": effort
        }
    
    return results

# Compare reasoning levels with your prompts
reasoning_comparison = generate_with_reasoning_levels(gpt_assistant_prompt, gpt_user_prompt)

print("\n🧠 Your Prompts with Different Reasoning Levels:")
for effort, result in reasoning_comparison.items():
    print(f"\n--- {effort.upper()} EFFORT ---")
    print(result["output"])
    print("-" * 50)

# Import required libraries
from pydantic import BaseModel
from typing import List

# Define the Pydantic model
class AssistantResponse(BaseModel):
    response: str
    key_points: List[str] 
    confidence_level: str
    follow_up_questions: List[str]

# Define the function - simplified for Weave compatibility
def generate_structured_with_pydantic_simple(assistant_prompt, user_prompt):
    """Generate structured output using Pydantic models - Weave-compatible version"""
    response = client.responses.parse(
        model="gpt-5",
        input=[
            {"role": "developer", "content": assistant_prompt},
            {"role": "user", "content": user_prompt}
        ],
        text_format=AssistantResponse
    )
    
    result = {
        "structured_data": response.output_parsed.model_dump(),
        "raw_output": response.output_text,
        "assistant_role": assistant_prompt,
        "validation_status": "valid"
    }
    return result

# Alternative: Manual logging approach to avoid Weave parsing issues
def log_and_call_pydantic(assistant_prompt, user_prompt):
    """Manually log the call to avoid Weave parsing errors"""
    print(f"📝 Calling Pydantic structured output...")
    print(f"   Assistant: {assistant_prompt[:50]}...")
    print(f"   User: {user_prompt[:50]}...")
    
    result = generate_structured_with_pydantic_simple(assistant_prompt, user_prompt)
    
    print(f"✅ Success! Generated {len(result['structured_data'])} structured fields")
    return result

# Test with Pydantic approach
print("Testing Pydantic structured output...")
try:
    pydantic_result = log_and_call_pydantic(gpt_assistant_prompt, gpt_user_prompt)
    print("✅ Pydantic Structured Output:")
    print(pydantic_result["structured_data"])
    print(f"Validation Status: {pydantic_result['validation_status']}")
except Exception as e:
    print(f"❌ Pydantic method failed: {e}")
    print("Falling back to JSON schema method...")

def generate_structured_with_json_schema(assistant_prompt, user_prompt):
    """Generate structured output using JSON schema"""
    schema = {
        "type": "object",
        "properties": {
            "response": {
                "type": "string",
                "description": "Main response from the assistant"
            },
            "key_points": {
                "type": "array",
                "items": {"type": "string"},
                "description": "Key points or takeaways"
            },
            "confidence_level": {
                "type": "string",
                "enum": ["low", "medium", "high"],
                "description": "Assistant's confidence in the response"
            },
            "follow_up_questions": {
                "type": "array", 
                "items": {"type": "string"},
                "description": "Suggested follow-up questions"
            }
        },
        "additionalProperties": False,
        "required": ["response", "key_points", "confidence_level", "follow_up_questions"]
    }
    
    response = client.responses.create(
        model="gpt-5",
        input=[
            {
                "role": "developer",
                "content": assistant_prompt
            },
            {
                "role": "user",
                "content": user_prompt
            }
        ],
        text={
            "format": {
                "type": "json_schema",
                "name": "assistant_response",  # This was missing!
                "strict": True,
                "schema": schema
            }
        }
    )
    
    import json
    parsed_data = json.loads(response.output_text)
    
    return {
        "structured_data": parsed_data,
        "raw_output": response.output_text,
        "assistant_role": assistant_prompt,
        "schema_used": schema,
        "validation_status": "valid"
    }

# Test with JSON schema approach
print("Testing JSON schema structured output...")
try:
    schema_result = generate_structured_with_json_schema(gpt_assistant_prompt, gpt_user_prompt)
    print("✅ JSON Schema Structured Output:")
    print(schema_result["structured_data"])
    print(f"Validation Status: {schema_result['validation_status']}")
except Exception as e:
    print(f"❌ JSON Schema method failed: {e}")
    print("This may be due to API differences - the Pydantic method above is more reliable.")

@weave.op()
def generate_structured_fallback(assistant_prompt: str, user_prompt: str) -> dict:
    """Fallback method using careful prompt engineering"""
    json_instructions = '''
    You must respond with valid JSON in exactly this format:
    {
        "response": "your main response here",
        "key_points": ["point 1", "point 2", "point 3"],
        "confidence_level": "low|medium|high",
        "follow_up_questions": ["question 1", "question 2"]
    }
    
    Output ONLY the JSON, no additional text.
    '''
    
    response = client.responses.create(
        model="gpt-5",
        reasoning={"effort": "medium"},
        input=[
            {
                "role": "developer",
                "content": f"{assistant_prompt}\n\n{json_instructions}"
            },
            {
                "role": "user",
                "content": user_prompt
            }
        ]
    )
    
    try:
        import json
        parsed_data = json.loads(response.output_text)
        return {
            "structured_data": parsed_data,
            "raw_output": response.output_text,
            "validation_status": "valid"
        }
    except json.JSONDecodeError as e:
        return {
            "structured_data": None,
            "raw_output": response.output_text,
            "validation_status": f"invalid JSON: {str(e)}",
            "error": str(e)
        }

# Try methods in order of preference
print("🔧 Testing Structured Output Methods:")

# Try Pydantic first (most reliable)
try:
    result = generate_structured_with_pydantic(gpt_assistant_prompt, gpt_user_prompt)
    print("✅ Success with Pydantic!")
    structured_result = result
except:
    print("⚠️ Pydantic failed, trying JSON schema...")
    # Try JSON schema
    try:
        result = generate_structured_with_json_schema(gpt_assistant_prompt, gpt_user_prompt)
        print("✅ Success with JSON schema!")
        structured_result = result
    except:
        print("⚠️ JSON schema failed, using prompt engineering fallback...")
        # Fallback to prompt engineering
        structured_result = generate_structured_fallback(gpt_assistant_prompt, gpt_user_prompt)
        print("📝 Using prompt engineering approach")

print(f"\nFinal structured result:")
if structured_result.get("structured_data"):
    print(structured_result["structured_data"])
    print(f"Status: {structured_result['validation_status']}")
else:
    print("Failed to generate valid structured output")
    print(f"Raw output: {structured_result['raw_output']}")

import base64
from PIL import Image
import io

def generate_image_with_gpt5(prompt: str) -> dict:
    """Generate an image using GPT-5's built-in image generation via tools"""
    try:
        response = client.responses.create(
            model="gpt-5",
            input=prompt,
            tools=[{"type": "image_generation"}],
        )
        
        # Extract the image data from the response
        image_data = [
            output.result
            for output in response.output
            if output.type == "image_generation_call"
        ]
        
        if image_data:
            image_base64 = image_data[0]
            
            # Convert base64 to PIL Image for Weave display
            image_bytes = base64.b64decode(image_base64)
            image = Image.open(io.BytesIO(image_bytes))
            
            return {
                "image": image,  # PIL Image object for Weave
                "image_base64": image_base64,
                "prompt_used": prompt,
                "status": "success"
            }
        else:
            return {"error": "No image data found in response"}
            
    except Exception as e:
        return {"error": str(e)}

@weave.op()
def create_image_for_existing_content(assistant_prompt: str, existing_content: dict) -> dict:
    """Generate an image based on previously created content"""
    
    # Extract the main response from our structured content
    main_response = existing_content.get("structured_data", {}).get("response", "")
    key_points = existing_content.get("structured_data", {}).get("key_points", [])
    
    if not main_response:
        return {"error": "No existing content found to create image for"}
    
    # Step 1: Have your assistant create an image prompt based on the existing content
    image_prompt_response = client.responses.create(
        model="gpt-5",
        reasoning={"effort": "low"},
        input=[
            {
                "role": "developer",
                "content": f"{assistant_prompt} Now act as a visual artist and create a detailed image description that would perfectly complement the content you previously created. Focus on visual elements, style, mood, and composition. Keep it under 300 characters for optimal image generation."
            },
            {
                "role": "user",
                "content": f"Create an image description for this content you generated:\n\nMain response: {main_response}\n\nKey points: {', '.join(key_points)}\n\nDescribe an image that would enhance and complement this content."
            }
        ]
    )
    
    image_prompt = image_prompt_response.output_text
    print(f"🎨 Your assistant's image prompt: {image_prompt}")
    
    # Step 2: Generate the image using GPT-5's tool-based image generation
    image_result = generate_image_with_gpt5(f"Generate an image: {image_prompt}")
    
    return {
        "original_content": existing_content,
        "image_prompt": image_prompt,
        "image_result": image_result,
        "assistant_role": assistant_prompt,
        "generated_image": image_result.get("image") if "error" not in image_result else None  # PIL Image for Weave
    }

# Use the structured content from Step 8 to create an accompanying image
print("🖼️ Creating an image for your previously generated content...")

# Check if we have structured content from previous steps
if 'pydantic_result' in locals() and pydantic_result.get("structured_data"):
    print(f"Using content: '{pydantic_result['structured_data']['response'][:50]}...'")
    
    multimodal_result = create_image_for_existing_content(gpt_assistant_prompt, pydantic_result)
    
    if "error" not in multimodal_result:
        print(f"\n📝 Original Content:")
        print(f"'{multimodal_result['original_content']['structured_data']['response']}'")
        
        print(f"\n🎨 Image Concept:")
        print(f"'{multimodal_result['image_prompt']}'")
        
        if "error" not in multimodal_result["image_result"]:
            print(f"✅ Image generated successfully!")
            
            # Display the image - Weave will show this in the dashboard
            generated_image = multimodal_result["generated_image"]
            if generated_image:
                print("🖼️ Generated image will appear in Weave dashboard")
                # You can also display it in Jupyter if running there
                try:
                    from IPython.display import display
                    display(generated_image)
                except ImportError:
                    pass
        else:
            print(f"❌ Image generation failed: {multimodal_result['image_result']['error']}")
    else:
        print(f"❌ Error: {multimodal_result['error']}")

@weave.op()
def create_personalized_tutorial_summary(assistant_prompt: str, user_prompt: str) -> dict:
    """Generate a personalized summary of your GPT-5 tutorial experience"""
    summary_request = f"""
    Based on our tutorial session where you were '{assistant_prompt}' and I asked you to '{user_prompt}', 
    please summarize what we accomplished with GPT-5's features:
    
    1. Basic Responses API with custom role prompts
    2. Reasoning effort level comparisons (low/medium/high)
    3. Structured JSON output generation
    4. Multimodal content creation with image generation
    5. Advanced prompt engineering techniques
    
    Reflect on how your specific role affected the outputs and what developers can learn.
    """
    
    response = client.responses.create(
        model="gpt-5",
        reasoning={"effort": "high"},  # Use high effort for final summary
        input=[
            {
                "role": "developer", 
                "content": f"{assistant_prompt} Provide a thoughtful, comprehensive summary with insights about the tutorial experience."
            },
            {
                "role": "user",
                "content": summary_request
            }
        ]
    )
    
    return {
        "personalized_summary": response.output_text,
        "original_assistant_role": assistant_prompt,
        "original_user_request": user_prompt,
        "tutorial_features": [
            "Custom role-based prompting",
            "Responses API usage", 
            "Reasoning effort controls",
            "Structured JSON outputs",
            "Image generation integration",
            "Multimodal content creation",
            "Comprehensive Weave logging"
        ]
    }

final_summary = create_personalized_tutorial_summary(gpt_assistant_prompt, gpt_user_prompt)
print("🎯 Your Personalized Tutorial Summary:")
print(final_summary["personalized_summary"])

print(f"\n📊 Session Details:")
print(f"Your Assistant Role: {final_summary['original_assistant_role']}")
print(f"Your Request: {final_summary['original_user_request']}")
print(f"Features Explored: {', '.join(final_summary['tutorial_features'])}")