Generative AI Fundamentals on Google Cloud¶

from google.cloud import aiplatform

aiplatform.init(project='my-project', location='us-central1')

# Access Llama 2 from Model Garden
endpoint = aiplatform.Endpoint(
    endpoint_name='projects/PROJECT_ID/locations/us-central1/endpoints/ENDPOINT_ID'
)

response = endpoint.predict(
    instances=[{"prompt": "Explain quantum computing"}]
)

# Text to tokens
text = "Generative AI is transforming technology"

# Tokenized (approximate):
# ["Gener", "ative", " AI", " is", " transform", "ing", " technology"]

# Each token → unique integer ID
# Token IDs: [1234, 5678, 910, 11, 1213, 1415, 1617]

from vertexai.preview.language_models import TextGenerationModel

model = TextGenerationModel.from_pretrained("text-bison@002")

response = model.predict(
    prompt="Write a short story about AI",
    temperature=0.7,
    max_output_tokens=1024,
    top_k=40,
    top_p=0.95
)

print(response.text)

from vertexai.preview.language_models import ChatModel

chat_model = ChatModel.from_pretrained("chat-bison@002")

chat = chat_model.start_chat(
    context="You are a helpful Python programming tutor",
    examples=[
        ["What is a list?", "A list in Python is an ordered, mutable collection..."],
    ]
)

response = chat.send_message("How do I create a dictionary?")
print(response.text)

response = chat.send_message("Can you show an example?")
print(response.text)

from vertexai.preview.language_models import CodeGenerationModel

code_model = CodeGenerationModel.from_pretrained("code-bison@002")

response = code_model.predict(
    prefix="Write a Python function to calculate fibonacci numbers"
)

print(response.text)

from vertexai.preview.vision_models import ImageGenerationModel

imagen = ImageGenerationModel.from_pretrained("imagegeneration@005")

images = imagen.generate_images(
    prompt="A futuristic city at sunset, cyberpunk style",
    number_of_images=4,
    aspect_ratio="1:1",
    safety_filter_level="block_few",
    person_generation="allow_adult"
)

for i, image in enumerate(images):
    image.save(f"generated_image_{i}.png")

from vertexai.preview.language_models import TextGenerationModel

model = TextGenerationModel.from_pretrained("text-bison@002")

prompt = """
Extract the product name and price from the following text:

Text: "Buy the iPhone 15 Pro for $999"
Product: iPhone 15 Pro
Price: $999

Text: "Get the Samsung Galaxy S24 now at $849.99"
Product: Samsung Galaxy S24
Price: $849.99

Text: "MacBook Air M2 available for $1199"
Product:"""

response = model.predict(prompt, temperature=0.2, max_output_tokens=50)
print(response.text)
# Output: MacBook Air M2
# Price: $1199

chat_model = ChatModel.from_pretrained("chat-bison@002")

chat = chat_model.start_chat(
    context="""You are a senior DevOps engineer specializing in Kubernetes
    and cloud-native architectures. You provide practical, production-ready
    advice with security best practices in mind."""
)

response = chat.send_message(
    "How should I structure my Kubernetes deployments for a microservices app?"
)
print(response.text)

# Output will be tailored to the DevOps engineer persona

# Factual, consistent output
response = model.predict(
    prompt="What is the capital of France?",
    temperature=0.2,
    top_k=40,
    top_p=0.8
)

# Creative, diverse output
response = model.predict(
    prompt="Write a creative story about space exploration",
    temperature=0.9,
    top_k=100,
    top_p=0.95
)

images = imagen.generate_images(
    prompt="A beautiful mountain landscape at sunset",
    negative_prompt="people, buildings, cars, roads, text, watermark",
    number_of_images=4
)

prompt = """
Summarize the following article in 3 bullet points, focusing on:
- Main topic or thesis
- Key findings or arguments
- Practical implications

Article:
[Article text here]

Summary:
"""

prompt = """
Write a Python function that:
- Takes a list of numbers as input
- Returns the median value
- Handles even and odd length lists
- Includes error handling for empty lists
- Add docstring and type hints

Function:
"""

prompt = """
Extract the following information from the resume:
- Name
- Email
- Phone
- Years of experience
- Top 3 skills
- Most recent job title

Return as JSON.

Resume:
[Resume text]

JSON:
"""

prompt = """
Create a LinkedIn post about:
Topic: Cloud migration success story
Tone: Professional but conversational
Length: 150-200 words
Include: Specific metrics, lessons learned, call-to-action
Hashtags: 3-5 relevant tags

Post:
"""

prompt = """
Translate the following technical documentation from English to Spanish:
- Maintain technical terms in English where appropriate
- Preserve formatting and structure
- Keep code snippets unchanged

Text:
[Documentation text]

Translation:
"""

from vertexai.preview.language_models import TextGenerationModel

base_model = TextGenerationModel.from_pretrained("text-bison@002")

tuning_job = base_model.tune_model(
    training_data="gs://my-bucket/training_data.jsonl",
    train_steps=100,
    learning_rate=0.001,
    tuned_model_location="gs://my-bucket/tuned_models"
)

prompt = """
Write a 500-word blog post for a technical audience about:
Topic: Kubernetes security best practices
Tone: Professional, informative
Structure: Introduction, 3 main sections, conclusion
Include: Code examples, specific tools, actionable tips
"""

response = model.predict(prompt, temperature=0.7, max_output_tokens=1024)

from vertexai.preview.language_models import CodeGenerationModel

code_model = CodeGenerationModel.from_pretrained("code-bison@002")

prompt = """
Write a Python function that:
1. Takes a list of dictionaries as input
2. Each dict has 'name', 'age', 'salary' keys
3. Returns the top 3 employees by salary
4. Handle edge cases (empty list, ties)
5. Include type hints and docstring
"""

response = code_model.predict(prefix=prompt)
print(response.text)

prompt = """
Summarize the following research paper abstract:

Abstract: [Long technical abstract about quantum computing]

Provide:
1. One-sentence summary for non-technical audience
2. Three key findings
3. Practical implications

Summary:
"""

response = model.predict(prompt, temperature=0.3, max_output_tokens=256)

prompt = """
Translate the following from English to Japanese:
- Maintain professional business tone
- Keep technical terms in English where standard
- Preserve markdown formatting

Text:
"Our API supports REST and GraphQL endpoints. Authentication uses OAuth 2.0."

Translation:
"""

prompt = "What is the capital of Australia?"
# Temperature: 0.1-0.2 (deterministic)

prompt = "Explain why microservices architecture is beneficial for large applications."
# Temperature: 0.4-0.6 (balanced)

prompt = """
Context: [Document or passage]

Question: Based on the context above, what were the main causes of the event?

Answer:
"""
# Temperature: 0.2-0.4

prompt = """
Information:
- Company A acquired Company B in 2020
- Company B was founded by John Smith
- John Smith started Company C in 2022

Question: Who started a new company two years after their previous company was acquired?

Think step by step:
"""

from vertexai.language_models import TextEmbeddingModel

embedding_model = TextEmbeddingModel.from_pretrained("textembedding-gecko@003")

# Single text embedding
text = "What is machine learning?"
embeddings = embedding_model.get_embeddings([text])
vector = embeddings[0].values  # 768-dimensional vector

# Batch embeddings
texts = ["AI is transforming industries", "Machine learning enables predictions"]
embeddings = embedding_model.get_embeddings(texts)

import numpy as np

def cosine_similarity(vec1, vec2):
    return np.dot(vec1, vec2) / (np.linalg.norm(vec1) * np.linalg.norm(vec2))

# Compare document similarity
similarity = cosine_similarity(embeddings[0].values, embeddings[1].values)

import vertexai
from vertexai.preview.generative_models import GenerativeModel, Part

model = GenerativeModel("gemini-pro-vision")

image_part = Part.from_uri("gs://my-bucket/image.jpg", mime_type="image/jpeg")
text_part = "What objects are in this image? Describe their arrangement."

response = model.generate_content([image_part, text_part])
print(response.text)

video_part = Part.from_uri("gs://my-bucket/video.mp4", mime_type="video/mp4")
prompt = "Summarize the key events in this video."

response = model.generate_content([video_part, prompt])

from vertexai.preview.generative_models import HarmCategory, HarmBlockThreshold

safety_settings = {
    HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
    HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_ONLY_HIGH,
    HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
    HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
}

response = model.generate_content(
    prompt,
    safety_settings=safety_settings
)

try:
    response = model.generate_content(prompt, safety_settings=safety_settings)
    print(response.text)
except Exception as e:
    if "blocked" in str(e).lower():
        print("Response blocked by safety filters")
        # Implement fallback logic
    else:
        raise

# Test across demographic variations
test_prompts = [
    "The engineer solved the problem. {pronoun} was skilled.",
    # Test with: he, she, they

    "The {profession} arrived at work.",
    # Test with: doctor, nurse, CEO, assistant
]

# Include fairness instructions in prompt
prompt = """
Provide career advice for a software engineer.

Important: Ensure advice is inclusive and does not make assumptions
based on gender, age, ethnicity, or other protected characteristics.
Focus on skills, experience, and professional development.

Question: What skills should I develop to advance my career?
"""

def safe_generate(prompt, model):
    # Input moderation
    if contains_pii(prompt):
        return "Error: Please remove personal information"

    if is_harmful_request(prompt):
        return "Error: Request violates content policy"

    # Generate with safety settings
    response = model.predict(
        prompt,
        safety_settings=STRICT_SAFETY_SETTINGS
    )

    # Output moderation
    if is_toxic(response.text):
        return "Response filtered due to content policy"

    return response.text

from google.cloud import dlp_v2

def detect_pii(text):
    dlp = dlp_v2.DlpServiceClient()

    info_types = [
        {"name": "EMAIL_ADDRESS"},
        {"name": "PHONE_NUMBER"},
        {"name": "CREDIT_CARD_NUMBER"},
        {"name": "US_SOCIAL_SECURITY_NUMBER"},
    ]

    inspect_config = {"info_types": info_types}
    item = {"value": text}

    response = dlp.inspect_content(
        request={"parent": f"projects/{project_id}",
                "inspect_config": inspect_config,
                "item": item}
    )

    return response.result.findings

def redact_pii(text):
    findings = detect_pii(text)

    for finding in findings:
        text = text.replace(finding.quote, "[REDACTED]")

    return text

# Use before sending to model
safe_prompt = redact_pii(user_input)
response = model.predict(safe_prompt)

import vertexai
from vertexai.preview.language_models import TextGenerationModel

vertexai.init(project="my-project", location="us-central1")

model = TextGenerationModel.from_pretrained("text-bison@002")
response = model.predict("Explain quantum computing")

from vertexai.preview.generative_models import GenerativeModel

model = GenerativeModel("gemini-pro-vision")

# Process invoice image
invoice_image = Part.from_uri("gs://bucket/invoice.pdf", mime_type="application/pdf")

prompt = """
Extract the following information from this invoice:
- Invoice number
- Date
- Vendor name
- Total amount
- Line items with descriptions and prices

Return as structured JSON.
"""

response = model.generate_content([invoice_image, prompt])
print(response.text)

from vertexai.preview.language_models import ChatModel

chat_model = ChatModel.from_pretrained("chat-bison@002")

# Configure chatbot with context
chat = chat_model.start_chat(
    context="""You are a customer service agent for TechCorp, a cloud services company.
    You help customers with:
    - Account issues
    - Billing questions
    - Technical support
    - Service information

    Be helpful, professional, and concise. Escalate complex issues to human agents.
    """,
    examples=[
        ["How do I reset my password?",
         "To reset your password: 1) Go to techcorp.com/login 2) Click 'Forgot Password' 3) Enter your email 4) Follow the link in your email. Let me know if you need help!"],
        ["What's the status of my ticket #12345?",
         "Let me check that for you. Could you please provide your account email address so I can look up your ticket?"]
    ]
)

# Multi-turn conversation
response = chat.send_message("I can't login to my account")
print(response.text)

response = chat.send_message("I tried resetting my password but didn't get an email")
print(response.text)

def generate_product_description(product_info):
    prompt = f"""
    Create a compelling product description for:

    Product: {product_info['name']}
    Category: {product_info['category']}
    Key Features: {', '.join(product_info['features'])}
    Target Audience: {product_info['audience']}

    Requirements:
    - Length: 150-200 words
    - Tone: {product_info['tone']}
    - Include benefits, not just features
    - Add call-to-action
    - SEO-friendly

    Description:
    """

    response = model.predict(prompt, temperature=0.8, max_output_tokens=512)
    return response.text

# Example usage
product = {
    'name': 'CloudSync Pro',
    'category': 'Cloud Storage',
    'features': ['256-bit encryption', 'Real-time sync', 'Team collaboration'],
    'audience': 'Small businesses',
    'tone': 'Professional yet approachable'
}

description = generate_product_description(product)

def generate_content_variations(base_content, num_variations=3):
    """Generate multiple variations for A/B testing"""
    variations = []

    for i in range(num_variations):
        prompt = f"""
        Rewrite the following content with a different approach while maintaining the core message:

        Original: {base_content}

        Variation {i+1} should be:
        - Unique in structure and word choice
        - Same length (±10%)
        - Maintain key information

        Rewritten version:
        """

        response = model.predict(prompt, temperature=0.9)
        variations.append(response.text)

    return variations

from vertexai.preview.language_models import CodeGenerationModel, CodeChatModel

code_model = CodeGenerationModel.from_pretrained("code-bison@002")
codechat_model = CodeChatModel.from_pretrained("codechat-bison@002")

# Generate function
function_prompt = """
Create a Python function that implements a rate limiter using the token bucket algorithm:
- Max capacity: 100 tokens
- Refill rate: 10 tokens per second
- Thread-safe implementation
- Include type hints and docstring
"""

code = code_model.predict(prefix=function_prompt)
print(code.text)

# Generate unit tests
test_prompt = f"""
Write comprehensive pytest unit tests for the following function:

{code.text}

Include tests for:
- Normal operation
- Edge cases (empty bucket, max capacity)
- Concurrent access
- Time-based refill
"""

tests = code_model.predict(prefix=test_prompt)
print(tests.text)

# Code review
codechat = codechat_model.start_chat()
review = codechat.send_message(f"""
Review this code for:
- Security vulnerabilities
- Performance issues
- Code quality and best practices
- Potential bugs

Code:
{code.text}
""")
print(review.text)

def generate_training_data(category, num_examples, existing_examples=None):
    """Generate synthetic training examples"""

    prompt = f"""
    Generate {num_examples} diverse examples of {category}.

    Requirements:
    - Each example should be unique
    - Cover different scenarios and edge cases
    - Realistic and varied
    - Include both common and uncommon cases

    {f"Existing examples for reference: {existing_examples}" if existing_examples else ""}

    Generate examples as JSON array:
    """

    response = model.predict(
        prompt,
        temperature=0.9,  # High creativity for diversity
        max_output_tokens=2048
    )

    return response.text

# Example: Generate customer support queries
support_queries = generate_training_data(
    category="customer support queries about billing issues",
    num_examples=20
)

# Example: Generate product reviews
reviews = generate_training_data(
    category="product reviews for a smartphone",
    num_examples=50,
    existing_examples=["Great camera quality!", "Battery lasts all day"]
)

def augment_dataset(examples, variations_per_example=3):
    """Create variations of existing examples"""
    augmented_data = []

    for example in examples:
        prompt = f"""
        Create {variations_per_example} variations of the following text:
        - Maintain the core meaning
        - Use different phrasing
        - Vary sentence structure
        - Keep the same sentiment/intent

        Original: {example}

        Variations:
        """

        response = model.predict(prompt, temperature=0.8)
        augmented_data.extend([example] + response.text.split('\n'))

    return augmented_data

from vertexai.language_models import TextEmbeddingModel, TextGenerationModel
import numpy as np

# Initialize models
embedding_model = TextEmbeddingModel.from_pretrained("textembedding-gecko@003")
generation_model = TextGenerationModel.from_pretrained("text-bison@002")

def create_knowledge_base(documents):
    """Create embeddings for document corpus"""
    embeddings = embedding_model.get_embeddings(documents)
    return {
        'documents': documents,
        'embeddings': [emb.values for emb in embeddings]
    }

def semantic_search(query, knowledge_base, top_k=3):
    """Find most relevant documents"""
    query_embedding = embedding_model.get_embeddings([query])[0].values

    # Calculate similarities
    similarities = []
    for doc_embedding in knowledge_base['embeddings']:
        sim = np.dot(query_embedding, doc_embedding) / (
            np.linalg.norm(query_embedding) * np.linalg.norm(doc_embedding)
        )
        similarities.append(sim)

    # Get top k documents
    top_indices = np.argsort(similarities)[-top_k:][::-1]
    return [knowledge_base['documents'][i] for i in top_indices]

def answer_with_rag(question, knowledge_base):
    """Answer question using RAG"""
    # Retrieve relevant documents
    relevant_docs = semantic_search(question, knowledge_base)

    # Generate answer with context
    prompt = f"""
    Context:
    {chr(10).join(f"- {doc}" for doc in relevant_docs)}

    Question: {question}

    Based on the context above, provide a detailed answer.
    If the context doesn't contain enough information, say so.

    Answer:
    """

    response = generation_model.predict(prompt, temperature=0.3)
    return response.text

# Example usage
knowledge_base = create_knowledge_base([
    "Cloud Run is a fully managed serverless platform for containers.",
    "Vertex AI provides ML model training and deployment services.",
    "BigQuery is a serverless data warehouse for analytics."
])

answer = answer_with_rag(
    "What is Cloud Run?",
    knowledge_base
)

def localize_content(content, target_language, target_region):
    """Translate and culturally adapt content"""

    prompt = f"""
    Translate and localize the following content:

    Source: {content}
    Target Language: {target_language}
    Target Region: {target_region}

    Requirements:
    - Accurate translation
    - Cultural adaptation for {target_region}
    - Maintain tone and intent
    - Adapt idioms and expressions
    - Keep formatting (markdown, etc.)

    Localized content:
    """

    response = model.predict(prompt, temperature=0.3)
    return response.text

def analyze_review_batch(reviews):
    """Analyze multiple reviews efficiently"""

    # Create structured prompt
    prompt = """
    Analyze the following customer reviews and provide:
    1. Sentiment (positive/negative/neutral) for each
    2. Key topics mentioned (features, issues, suggestions)
    3. Overall summary with action items

    Reviews:
    """

    for i, review in enumerate(reviews, 1):
        prompt += f"\nReview {i}: {review}"

    prompt += """

    Return analysis as JSON:
    {
      "reviews": [
        {"id": 1, "sentiment": "positive", "topics": ["feature1", "feature2"], "key_points": "..."}
      ],
      "summary": "...",
      "action_items": ["..."]
    }
    """

    response = model.predict(
        prompt,
        temperature=0.2,  # Low for consistency
        max_output_tokens=2048
    )

    return response.text

# Example
reviews = [
    "The product is amazing! Fast shipping and great quality.",
    "Disappointed. Item arrived broken and customer service was unhelpful.",
    "It's okay. Does what it says but nothing special."
]

analysis = analyze_review_batch(reviews)

from vertexai.preview.language_models import CodeChatModel

codechat = CodeChatModel.from_pretrained("codechat-bison@002").start_chat()

def generate_documentation(code):
    """Generate comprehensive code documentation"""

    prompt = f"""
    Generate comprehensive documentation for the following code:

    ```python
    {code}
    ```

    Include:
    1. Function/class description
    2. Parameters with types and descriptions
    3. Return value description
    4. Usage examples
    5. Notes about edge cases or limitations

    Use Google-style docstring format.
    """

    response = codechat.send_message(prompt)
    return response.text

# Example
code = """
def process_data(items, threshold=0.5, validate=True):
    results = []
    for item in items:
        if validate and not is_valid(item):
            continue
        score = calculate_score(item)
        if score > threshold:
            results.append(item)
    return results
"""

documentation = generate_documentation(code)

def multilingual_support_bot(customer_message, knowledge_base):
    """Handle customer support in any language"""

    # First, detect intent in original language
    intent_prompt = f"""
    Customer message: {customer_message}

    Identify:
    1. Language of the message
    2. Customer intent (billing, technical_support, account, general_inquiry)
    3. Urgency level (low, medium, high)
    4. Key entities (account numbers, product names, etc.)

    Return as JSON.
    """

    intent_response = model.predict(intent_prompt, temperature=0.2)

    # Generate response
    support_prompt = f"""
    You are a customer support agent. A customer sent this message:

    Message: {customer_message}

    Context from knowledge base:
    {knowledge_base}

    Provide:
    1. Helpful response in the SAME language as the customer's message
    2. Professional and empathetic tone
    3. Step-by-step instructions if applicable
    4. Escalation recommendation if needed

    Response:
    """

    response = chat_model.predict(support_prompt, temperature=0.4)
    return response.text

# Example
customer_msg = "Bonjour, je n'arrive pas à me connecter à mon compte"
knowledge_base = "Login issues: Check password, clear cache, verify email"

response = multilingual_support_bot(customer_msg, knowledge_base)

def analyze_contract(contract_text):
    """Extract structured information from contract"""

    prompt = f"""
    Analyze the following contract and extract:

    Contract:
    {contract_text}

    Extract:
    1. Parties (names and roles)
    2. Effective date and term
    3. Financial terms (amounts, payment schedule)
    4. Key obligations for each party
    5. Termination conditions
    6. Unusual or high-risk clauses

    Return as structured JSON with confidence scores for each extraction.
    """

    response = model.predict(
        prompt,
        temperature=0.1,  # Very low for factual extraction
        max_output_tokens=2048
    )

    return response.text

# For multi-page PDFs with Gemini Vision
def analyze_contract_pdf(pdf_uri):
    """Analyze contract from PDF"""
    vision_model = GenerativeModel("gemini-pro-vision")

    pdf_part = Part.from_uri(pdf_uri, mime_type="application/pdf")

    prompt = """Extract key contract terms from this PDF:
    - Parties and roles
    - Dates and deadlines
    - Financial terms
    - Key obligations
    - Risk factors

    Format as JSON.
    """

    response = vision_model.generate_content([pdf_part, prompt])
    return response.text

from vertexai.preview.generative_models import HarmCategory, HarmBlockThreshold

def moderate_content(user_content):
    """Multi-stage content moderation"""

    # Stage 1: Safety filter check
    safety_settings = {
        HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
        HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
        HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
        HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
    }

    # Stage 2: Detailed analysis
    analysis_prompt = f"""
    Analyze this user-generated content for policy violations:

    Content: {user_content}

    Check for:
    1. Hate speech or harassment
    2. Violence or dangerous content
    3. Spam or misleading information
    4. Personal attacks
    5. Policy-specific violations

    Return:
    {{
      "is_safe": true/false,
      "violations": ["type1", "type2"],
      "severity": "low/medium/high",
      "confidence": 0.0-1.0,
      "explanation": "...",
      "recommended_action": "approve/review/reject"
    }}
    """

    try:
        response = model.generate_content(
            analysis_prompt,
            safety_settings=safety_settings
        )

        moderation_result = response.text

        # Stage 3: PII check
        if contains_pii(user_content):
            moderation_result['pii_detected'] = True
            moderation_result['recommended_action'] = 'review'

        return moderation_result

    except Exception as e:
        # Content blocked by safety filters
        return {
            'is_safe': False,
            'violations': ['safety_filter_triggered'],
            'severity': 'high',
            'recommended_action': 'reject',
            'error': str(e)
        }

def generate_test_suite(feature_description, code=None):
    """Generate comprehensive test suite"""

    prompt = f"""
    Generate a comprehensive test suite for:

    Feature: {feature_description}
    {f"Implementation: {code}" if code else ""}

    Create:
    1. Unit tests for core functionality
    2. Edge case tests (empty inputs, boundaries, nulls)
    3. Integration tests if applicable
    4. Performance/load tests
    5. Security tests (injection, validation)

    Requirements:
    - Use pytest framework
    - Include setup and teardown
    - Add descriptive test names
    - Include assertions with messages
    - Cover positive and negative cases

    Test suite:
    """

    response = code_model.predict(prefix=prompt, max_output_tokens=2048)
    return response.text

# Example
feature = """
API endpoint: POST /api/users
- Creates new user account
- Validates email format
- Checks for duplicate emails
- Requires password (min 8 chars)
- Returns user ID on success
"""

test_suite = generate_test_suite(feature)

def generate_personalized_email(customer_segment, campaign_goal, customer_data):
    """Generate personalized email content"""

    prompt = f"""
    Create a personalized email for:

    Customer Segment: {customer_segment}
    Campaign Goal: {campaign_goal}

    Customer Data:
    - Name: {customer_data.get('name', 'Valued Customer')}
    - Purchase History: {customer_data.get('purchase_history', 'New customer')}
    - Interests: {', '.join(customer_data.get('interests', []))}
    - Engagement Level: {customer_data.get('engagement', 'medium')}

    Email Requirements:
    - Subject line (compelling, under 50 chars)
    - Greeting (personalized)
    - Body (2-3 paragraphs, conversational tone)
    - Personalized product recommendations
    - Clear call-to-action
    - Sign-off

    Brand Voice: Professional yet friendly, helpful, not pushy

    Email:
    """

    response = model.predict(
        prompt,
        temperature=0.7,  # Balanced for personalization
        max_output_tokens=512
    )

    return response.text

def generate_ab_variations(base_email, num_variations=3):
    """Create A/B test variations"""
    variations = []

    for i in range(num_variations):
        prompt = f"""
        Create a variation of this email that tests a different approach:

        Original:
        {base_email}

        Variation {i+1} should:
        - Keep the same core message
        - Try a different hook/opening
        - Vary the CTA placement or wording
        - Adjust tone slightly (more urgent, more casual, etc.)

        Variation:
        """

        response = model.predict(prompt, temperature=0.8)
        variations.append(response.text)

    return variations

# Example
customer = {
    'name': 'Sarah',
    'purchase_history': 'Purchased laptop 3 months ago',
    'interests': ['productivity software', 'tech gadgets'],
    'engagement': 'high'
}

email = generate_personalized_email(
    customer_segment='tech_enthusiast',
    campaign_goal='Promote new software bundle',
    customer_data=customer
)

variations = generate_ab_variations(email, num_variations=2)

def summarize_meeting(transcript):
    """Generate comprehensive meeting summary"""

    prompt = f"""
    Analyze this meeting transcript and provide:

    Transcript:
    {transcript}

    Generate:
    1. Executive Summary (2-3 sentences)
    2. Key Discussion Points (bulleted list)
    3. Decisions Made (list with context)
    4. Action Items (task, owner, deadline if mentioned)
    5. Open Questions or Follow-ups
    6. Next Steps

    Format as structured JSON for easy parsing.

    Summary:
    """

    response = model.predict(
        prompt,
        temperature=0.3,  # Low for factual extraction
        max_output_tokens=1024
    )

    return response.text

def extract_action_items(transcript):
    """Extract specific action items with tracking"""

    prompt = f"""
    Extract all action items from this meeting transcript:

    {transcript}

    For each action item, identify:
    - Task description
    - Person responsible (if mentioned)
    - Deadline (if mentioned)
    - Priority (inferred from context)
    - Dependencies

    Return as JSON array:
    [
      {{
        "task": "...",
        "owner": "...",
        "deadline": "...",
        "priority": "high/medium/low",
        "dependencies": [...]
      }}
    ]
    """

    response = model.predict(prompt, temperature=0.2)
    return response.text

def generate_sql_query(question, schema):
    """Generate SQL from natural language"""

    prompt = f"""
    Database Schema:
    {schema}

    Question: {question}

    Generate:
    1. SQL query to answer the question
    2. Explanation of the query logic
    3. Expected result format

    Requirements:
    - Use proper joins and indexes
    - Include appropriate filters
    - Optimize for performance
    - Use standard SQL syntax

    SQL Query:
    """

    response = code_model.predict(prefix=prompt)

    return response.text

# Example
schema = """
Tables:
- customers (id, name, email, created_at)
- orders (id, customer_id, total, status, order_date)
- order_items (id, order_id, product_id, quantity, price)
- products (id, name, category, price)
"""

question = "What are the top 5 customers by total order value in the last 6 months?"

sql = generate_sql_query(question, schema)

from vertexai.preview.generative_models import GenerativeModel, Part

def analyze_product_image(image_uri, product_type):
    """Analyze product image for defects"""

    vision_model = GenerativeModel("gemini-pro-vision")

    image = Part.from_uri(image_uri, mime_type="image/jpeg")

    prompt = f"""
    Analyze this {product_type} image for quality control:

    Look for:
    1. Surface defects (scratches, dents, discoloration)
    2. Assembly issues (misalignment, gaps)
    3. Labeling problems (incorrect, missing, damaged)
    4. Packaging condition
    5. Overall quality assessment

    Provide:
    - Defects found (with locations)
    - Severity (minor, moderate, critical)
    - Pass/Fail recommendation
    - Detailed description
    - Suggested corrective actions

    Format as JSON.

    Analysis:
    """

    response = vision_model.generate_content([image, prompt])
    return response.text

# Batch processing
def batch_quality_inspection(image_uris, product_type):
    """Inspect multiple product images"""
    results = []

    for uri in image_uris:
        analysis = analyze_product_image(uri, product_type)
        results.append({
            'image': uri,
            'analysis': analysis
        })

    # Generate summary report
    summary_prompt = f"""
    Quality inspection results for {len(image_uris)} {product_type} items:

    {results}

    Generate summary report:
    - Total items inspected
    - Pass/fail breakdown
    - Common defects
    - Defect rate by category
    - Recommendations for process improvement

    Report:
    """

    summary = model.predict(summary_prompt, temperature=0.3)
    return results, summary.text

# 1. Create embeddings for knowledge base
embeddings = embedding_model.get_embeddings(documents)

# 2. Store vectors (Vector Search, Firestore)

# 3. For query:
#    a. Embed query
#    b. Find top-k similar documents (cosine similarity)
#    c. Include in prompt as context

# 4. Generate answer with context
response = model.predict(f"Context: {context}\nQuestion: {query}")

"""
Write a [language] [function/class] that:
1. [Requirement 1]
2. [Requirement 2]
3. [Requirement 3]

Include:
- Type hints / annotations
- Docstring
- Error handling
- Edge case handling

[Language] code:
"""

from vertexai.preview.language_models import TextGenerationModel
model = TextGenerationModel.from_pretrained("text-bison@002")
response = model.predict(prompt, temperature=0.7, max_output_tokens=1024)

from vertexai.preview.language_models import ChatModel
chat_model = ChatModel.from_pretrained("chat-bison@002")
chat = chat_model.start_chat(context="...", examples=[...])
response = chat.send_message("message")

from vertexai.preview.language_models import CodeGenerationModel
code_model = CodeGenerationModel.from_pretrained("code-bison@002")
response = code_model.predict(prefix="prompt")

from vertexai.preview.generative_models import GenerativeModel, Part
model = GenerativeModel("gemini-pro-vision")
image = Part.from_uri("gs://bucket/image.jpg", mime_type="image/jpeg")
response = model.generate_content([image, "prompt"])

from vertexai.language_models import TextEmbeddingModel
embedding_model = TextEmbeddingModel.from_pretrained("textembedding-gecko@003")
embeddings = embedding_model.get_embeddings(["text1", "text2"])

from vertexai.preview.generative_models import HarmCategory, HarmBlockThreshold
safety_settings = {
    HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
}