ChatGPT for Business Setup

Settings → Team → Members
├── Invite via email
├── Bulk upload (CSV)
├── Set roles (Admin, Member)
└── Configure access levels

GPT Builder → Create
├── Name and description
├── Instructions (system prompt)
├── Conversation starters
├── Knowledge files
├── Capabilities (web, code, DALL-E)
└── Actions (API integrations)

# Instructions

You are SalesBot, an AI assistant for the sales team at [Company].

## Your Knowledge
- Product catalog and pricing
- Competitor comparison matrix
- Sales playbooks and scripts
- Customer case studies

## Your Capabilities
- Generate personalized outreach emails
- Create meeting agendas based on prospect info
- Suggest responses to common objections
- Draft proposals and quotes
- Analyze competitor mentions

## Guidelines
- Always verify customer information before providing specific quotes
- Escalate enterprise deals (>$50k) to sales managers
- Use approved messaging and positioning only
- Track all customer interactions in CRM

## Conversation Starters
- "Help me draft a follow-up email for [prospect]"
- "What's our competitive advantage against [competitor]?"
- "Create a discovery call agenda for [company]"

openapi: 3.0.0
info:
  title: CRM Integration
  version: 1.0.0
servers:
  - url: https://api.yourcrm.com/v1
paths:
  /contacts/{id}:
    get:
      operationId: getContact
      summary: Get contact details
      parameters:
        - name: id
          in: path
          required: true
          schema:
            type: string
      responses:
        200:
          description: Contact details
          content:
            application/json:
              schema:
                type: object
                properties:
                  name:
                    type: string
                  email:
                    type: string
                  company:
                    type: string

Settings → API Keys → Create new secret key
├── Name your key (e.g., "production-app")
├── Set permissions (All, Read-only, etc.)
└── Copy and secure immediately

pip install openai

from openai import OpenAI

client = OpenAI(api_key="your-api-key")  # Or use OPENAI_API_KEY env var

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "You are a helpful business assistant."},
        {"role": "user", "content": "Summarize the key benefits of AI adoption for SMBs."}
    ],
    max_tokens=1000
)

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

npm install openai

import OpenAI from 'openai';

const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});

async function main() {
  const response = await openai.chat.completions.create({
    model: "gpt-4o",
    messages: [
      { role: "system", content: "You are a helpful business assistant." },
      { role: "user", content: "Summarize the key benefits of AI adoption for SMBs." }
    ],
    max_tokens: 1000
  });

  console.log(response.choices[0].message.content);
}

main();

response = client.chat.completions.create(
    model="gpt-4o",
    response_format={ "type": "json_object" },
    messages=[
        {"role": "system", "content": "Output valid JSON only."},
        {"role": "user", "content": """
            Analyze this customer feedback and return JSON:
            "The product is great but shipping took forever"

            Format:
            {
              "sentiment": "positive/negative/mixed",
              "topics": ["topic1", "topic2"],
              "action_required": true/false
            }
        """}
    ]
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_customer_data",
            "description": "Retrieve customer information from the CRM",
            "parameters": {
                "type": "object",
                "properties": {
                    "customer_id": {
                        "type": "string",
                        "description": "The unique customer identifier"
                    },
                    "fields": {
                        "type": "array",
                        "items": {"type": "string"},
                        "description": "Fields to retrieve"
                    }
                },
                "required": ["customer_id"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Look up customer C-12345"}],
    tools=tools,
    tool_choice="auto"
)

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Analyze this dashboard screenshot and identify any concerning metrics."},
                {
                    "type": "image_url",
                    "image_url": {
                        "url": "https://example.com/dashboard.png",
                        # Or use base64: "data:image/png;base64,..."
                    }
                }
            ]
        }
    ],
    max_tokens=1000
)

User: "Analyze this CSV of sales data and create a monthly trend chart"
ChatGPT:
1. Reads uploaded CSV
2. Processes data with pandas
3. Creates matplotlib visualization
4. Returns downloadable chart image

"Create a professional infographic showing the 5 stages of
the customer journey, using a clean blue and white color scheme,
modern flat design style"

class CRMIntegratedChatGPT:
    def __init__(self):
        self.openai = OpenAI()
        self.crm = YourCRMClient()

    async def process_customer_query(self, query: str, customer_id: str):
        # Fetch customer context from CRM
        customer = await self.crm.get_customer(customer_id)

        # Build context-aware prompt
        messages = [
            {
                "role": "system",
                "content": f"""You are a customer success assistant.

                Current Customer Context:
                - Name: {customer.name}
                - Plan: {customer.plan}
                - Account Age: {customer.tenure} months
                - Recent Issues: {customer.recent_tickets}
                - Health Score: {customer.health_score}

                Provide personalized, context-aware assistance."""
            },
            {"role": "user", "content": query}
        ]

        response = self.openai.chat.completions.create(
            model="gpt-4o",
            messages=messages
        )

        return response.choices[0].message.content

from slack_bolt import App
from openai import OpenAI

app = App(token=os.environ["SLACK_BOT_TOKEN"])
openai_client = OpenAI()

@app.event("app_mention")
def handle_mention(event, say):
    user_message = event["text"]

    response = openai_client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": "You are a helpful Slack assistant."},
            {"role": "user", "content": user_message}
        ]
    )

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

system_prompt = """
# Role
You are [specific role] for [company/context].

# Knowledge
- [Key fact 1]
- [Key fact 2]
- [Relevant domain knowledge]

# Guidelines
- [Behavior rule 1]
- [Behavior rule 2]
- [Output format requirements]

# Constraints
- [What NOT to do]
- [Escalation triggers]
- [Safety guardrails]
"""

messages = [
    {"role": "system", "content": "Convert customer queries into support tickets."},
    {"role": "user", "content": "My account won't load"},
    {"role": "assistant", "content": """
        Category: Technical Issue
        Priority: Medium
        Summary: Account access failure
        Details: User reports inability to load account
        Next Steps: Check service status, request browser/device info
    """},
    {"role": "user", "content": "I want a refund for my last purchase"},
    {"role": "assistant", "content": """
        Category: Billing
        Priority: High
        Summary: Refund request
        Details: Customer requesting refund for recent purchase
        Next Steps: Verify purchase, check refund policy, process or escalate
    """},
    {"role": "user", "content": actual_customer_query}
]

def optimize_prompt(content: str, max_chars: int = 10000) -> str:
    """Reduce token usage while preserving meaning."""
    # Truncate if too long
    if len(content) > max_chars:
        content = content[:max_chars] + "..."

    # Remove excessive whitespace
    content = " ".join(content.split())

    return content

def select_model(task_complexity: str) -> str:
    """Choose appropriate model based on task."""
    models = {
        "simple": "gpt-4o-mini",      # $0.15/1M input
        "standard": "gpt-4o",          # $2.50/1M input
        "complex": "gpt-4-turbo",      # $10.00/1M input
        "reasoning": "o1-preview"      # $15.00/1M input
    }
    return models.get(task_complexity, "gpt-4o")

import hashlib
from functools import lru_cache

@lru_cache(maxsize=1000)
def cached_completion(prompt_hash: str, model: str):
    # Cache completions for identical prompts
    pass

def get_completion(prompt: str, model: str = "gpt-4o"):
    prompt_hash = hashlib.md5(prompt.encode()).hexdigest()
    return cached_completion(prompt_hash, model)

# Environment variables (recommended)
import os
client = OpenAI()  # Uses OPENAI_API_KEY automatically

# Or use secrets manager
from your_secrets_manager import get_secret
client = OpenAI(api_key=get_secret("openai-api-key"))

def sanitize_input(user_input: str) -> str:
    """Basic input sanitization."""
    # Length limit
    max_length = 10000
    if len(user_input) > max_length:
        user_input = user_input[:max_length]

    # Remove potential prompt injection attempts
    suspicious_patterns = [
        "ignore previous",
        "disregard instructions",
        "new system prompt"
    ]
    for pattern in suspicious_patterns:
        user_input = user_input.replace(pattern, "[filtered]")

    return user_input

def validate_output(response: str, expected_format: str = "text") -> dict:
    """Validate and sanitize model output."""
    result = {"valid": True, "content": response, "warnings": []}

    # Check for sensitive data patterns
    sensitive_patterns = [
        r'\b\d{3}-\d{2}-\d{4}\b',  # SSN
        r'\b\d{16}\b',              # Credit card
        r'api[_-]?key.*=.*\w{20}',  # API keys
    ]

    import re
    for pattern in sensitive_patterns:
        if re.search(pattern, response, re.IGNORECASE):
            result["warnings"].append(f"Potential sensitive data detected")
            result["content"] = "[Content filtered for review]"

    return result

import time
from openai import RateLimitError

def request_with_backoff(messages, max_retries=5):
    for attempt in range(max_retries):
        try:
            return client.chat.completions.create(
                model="gpt-4o",
                messages=messages
            )
        except RateLimitError as e:
            if attempt == max_retries - 1:
                raise
            wait_time = 2 ** attempt
            time.sleep(wait_time)

def chunk_content(content: str, max_tokens: int = 100000):
    """Split content into processable chunks."""
    # Rough estimate: 1 token ≈ 4 characters
    max_chars = max_tokens * 4
    chunks = []

    while content:
        chunk = content[:max_chars]
        # Try to break at sentence boundary
        last_period = chunk.rfind('.')
        if last_period > max_chars * 0.8:
            chunk = content[:last_period + 1]

        chunks.append(chunk)
        content = content[len(chunk):]

    return chunks

import json

def get_json_response(prompt: str, schema: dict = None):
    """Get reliable JSON output."""
    for attempt in range(3):
        response = client.chat.completions.create(
            model="gpt-4o",
            response_format={"type": "json_object"},
            messages=[
                {"role": "system", "content": f"Return valid JSON matching: {json.dumps(schema)}"},
                {"role": "user", "content": prompt}
            ]
        )

        try:
            return json.loads(response.choices[0].message.content)
        except json.JSONDecodeError:
            continue

    raise ValueError("Failed to get valid JSON after 3 attempts")

Monthly ROI = (Value Generated - Total Cost) / Total Cost × 100

Value Generated:
- Time saved × Hourly rate
- Error reduction × Error cost
- Productivity improvement × Revenue impact

Total Cost:
- Subscription fees
- API costs
- Implementation time
- Training investment