Bienvenido a Platzi

🚀 Creation and Configuration of Customized GPTs in ChatGPT 🛠️

🔑 Key Concepts:

• You are Building an "Agent," Not a "Prompt": This is the fundamental shift. A Custom GPT is not just a saved prompt; it's a stateful, specialized agent. You are defining its core
  system
  prompt (Instructions), its persistent memory (Knowledge), and its tools (Capabilities & Actions).
• The Two-Pronged Build Process:
  1. "Create" Tab (Conversational Builder): This is your high-level "scaffolder." You use natural language to direct the
     GPT-Builder
     agent, which writes the instructions, name, and description for you. This is excellent for rapid prototyping and persona-tuning.
  2. "Configure" Tab (The "IDE"): This is your surgical tool. Here you directly edit the
     Instructions
     , upload your Knowledge files (the RAG component), and define Actions (the API-driven tools). A senior user prototypes in "Create" and refines in "Configure."
• Connecting Domains:
  • Startup/Strategy: This is Task-Specific Automation. You don't build one "Company GPT." You build a team of specialists: a
    PitchDeck_Analyst_GPT
    (fed with your last 10 investor decks), a
    Support_Ticket_Classifier_GPT
    (fed with Zendesk export), and a
    Marketing_Copy_GPT
    (fed with your brand voice guide).
  • Dev/AI: This is a no-code RAG + Agent framework. "Knowledge" is a built-in vector store for Retrieval-Augmented Generation (RAG). "Actions" are a user-friendly implementation of "Function Calling," allowing your agent to interact with the outside world (your APIs).

🏭 Industry & Startup Application:

• Company: A Series B MarTech startup launching a new product.
• Application: Building an internal "GTM Strategy Copilot" GPT to ensure all departments are aligned.
• The Process (via the "Configure" tab):
  1. Name/Description:
     GTM_Strategy_Copilot
     / "Analyzes our GTM plan and provides role-specific talking points."
  2. Instructions (The Core Logic):
     "You are a GTM strategist, modeled after Geoffrey Moore. Your sole purpose is to analyze the 'Knowledge' files. When a user asks a question (e.g., 'I'm in sales...'), you MUST retrieve context from the uploaded 'Product_Brief.pdf' and 'Brand_Voice.md' *first*. Then, provide a response in the persona of that user's department (e.g., Sales, Marketing, Support)."
  3. Knowledge (The "Brain" / RAG): The PM uploads 5 files:
     Product_Brief_v3.pdf
     ,
     Brand_Voice_Guide.md
     ,
     Competitor_Matrix_Q4.xlsx
     ,
     User_Personas.pdf
     , and
     Pricing_Model.docx
     .
  4. Capabilities:
     Web Browsing
     is enabled (to find new competitors),
     Image Generation
     is disabled (not relevant),
     Code Interpreter
     is enabled (to analyze the
     .xlsx
     ).
  5. Actions (The "Hands" / API): The CTO adds an Action (via OpenAPI schema) to connect to the company's internal Jira API.
• Why it Matters: Now, a sales rep can ask, "Give me 3 bullet points to use against Competitor X for our 'Enterprise' persona," and the GPT will synthesize an answer from the 5 "Knowledge" files. Then, they can say, "Great, now create a new Jira ticket for the product team about this." The GPT is a fully-integrated, specialist agent.

🔮 Future Steps & Project Hooks:

• Project Hook 1 (AI/Dev): Build a "RAG-Powered" Specialist. Create a Custom GPT focused on your other Platzi courses. Upload 10-15 key PDFs/notes from your Data Science or Marketing courses. Your "Instruction" goal:
  "You are a synthesizer. When I ask a question, you must answer by citing *at least two* of the uploaded documents, finding the connections *between* them."
• Project Hook 2 (Startup/Dev): Build Your First "Action" (API-Enabled GPT). Find a simple, public, no-auth API (like a "Random Quote API" or a "Weather API"). Go through the process of reading its documentation, writing the simple OpenAPI schema, and adding it to the "Actions" tab. This moves you from a "knowledge" bot to a "tool-using" agent.
• Next Step: The "Actions" feature is a UI for the OpenAI Assistants API. Your next logical step as a senior dev is to bypass the UI entirely. Your next step is to build a custom application that uses the
  Assistants API
  directly, giving you full programmatic control over file management (RAG), tool-use (Actions), and thread management.