Connectors: bringing your drive and tools in

Crucially, the model does not get a copy of your entire Drive dumped into the context windowcontext windowThe context window is the maximum amount of text (measured in tokens) a language model can process at once, including both the input prompt and the generated output.Voir la définition complète →. It runs a search, gets back the most relevant chunks, and reasons over those. Your foundations covered why: the context windowcontext windowThe context window is the maximum amount of text (measured in tokens) a language model can process at once, including both the input prompt and the generated output.Voir la définition complète → is finite, so retrieval beats stuffing.

See the official overview at help.openai.com for the current list of supported sources, which expands regularly.

A concrete "answer from our internal docs" example

Say your team keeps everything in Google Drive: a Pricing Policy 2026.gdoc, a folder of signed customer contracts, and a Security Questionnaire Responses.xlsx.

You connect Google Drive once (Settings, then Connectors, then authorize). Now in a normal chat:

> "What's our standard discount cap for multi-year deals, and which contracts have exceptions? Cite the docs."

ChatGPT will:

1. Search your connected Drive for relevant files (the pricing doc, the contracts folder).

2. Retrieve the matching passages.

3. Synthesize an answer like: "Standard cap is 15% for 2 or 3 year terms (Pricing Policy 2026, section 4). Two contracts exceed it: Acme (20%) and Globex (18%)."

4. Show citations linking back to the source files.

That last step is the point. You can click through and verify. An answer with no traceable source is a liability; a cited answer from your own contract is something you can act on.

What gets accessed (and what does not)

This is the part professionals get wrong, so be precise.

Permissions are inherited, not granted. When you connect Google Drive, ChatGPT acts as *you*. It can only see files your Google account can already see. If a folder is shared with you, it is reachable. If it is not, the connector cannot magic it into view. This matters most in Workspace and Enterprise setups where document permissions are tightly scoped.

Scope can be narrowed. Connectors and the admin controls let you limit what is connected. An organization can restrict which connectors are even available, and you can often scope a connection to specific folders rather than an entire drive.

Indexed content lives in OpenAI's systems for retrieval. For synced connectors, the content is processed and stored so it can be searched. Read your plan's data terms. On Team, Enterprise, and Edu, business data is not used to train OpenAI's models by default. See openai.com/enterprise-privacy for the current commitments.

Deleting the connection removes access. Revoke the OAuth grant in ChatGPT (or in Google's security settings) and the bridge is gone.

A quick mental rule: a Connector never *elevates* your access. It only *exposes* what you already have, to a model that can read fast.

Connectors vs. Actions vs. file uploads

You now have three ways to get external data into ChatGPT, and they are not interchangeable.

| Mechanism | Best for | Who controls it |

|---|---|---|

| File upload | One-off analysis of a specific file | You, per chat |

| Connectors | Standing access to a tool's content (Drive, SharePoint) | You / your admin |

| Actions (in Custom GPTs) | Calling an APIAPIApplication Programming Interface: a standardised interface that lets applications communicate and exchange data without knowing each other's internal workings.Voir la définition complète → to *do* something or fetch live data | The GPT builder |

The distinction that matters: Connectors read your knowledge sources; Actions call APIs. A Connector answers "what does our policy say?" An Action does "create the Jira ticket" or "look up this order's live status." We covered Actions in the previous lesson; Connectors are the read-heavy counterpart.

Connectors inside projects and custom gpts

Connectors get more powerful when scoped.

In a Project, you can attach connected sources alongside project files and custom instructions. Every chat inside that Project then answers against the same grounded context. A "Q4 RFP Responses" Project with your Drive connected means every drafted answer pulls from the real, current source material without re-uploading anything.

In a Custom GPT, a builder can wire a connector so that everyone using the GPT searches a shared, authorized knowledge base. Picture an internal "Sales Answer Bot" GPT connected to the team's SharePoint. Each user still only sees what their own permissions allow, but the GPT's behavior and source are standardized.

This is the difference between a clever prompt and a deployable internal tool: the source of truth is fixed, and the answers stay current as the underlying files change.

The deep-research and agent angle

Connectors are not just for one-shot Q&A. They feed ChatGPT's more autonomous modes.

When you run deep research or the ChatGPT agent, connected sources become part of the agent's toolset. A research run can pull from your internal Drive *and* the web in the same task. For example: "Compare our current pricing policy against the three competitor pages I'll paste, and flag where we're undercut." It reads your internal doc via the connector and the competitor pages via browsing, then reasons across both.

You can also pair this with scheduled tasks to get a recurring grounded briefing, for example a Monday summary of changes in a tracked Drive folder.

When you outgrow the ChatGPT UI: building it yourself

ChatGPT Connectors are the no-code path. When you need this behavior inside *your own* application, you move to the OpenAI APIAPIApplication Programming Interface: a standardised interface that lets applications communicate and exchange data without knowing each other's internal workings.Voir la définition complète →, where the equivalent capability is file search over a vector storevector storeA vector database stores data as high-dimensional numeric vectors (embeddings) and retrieves items by similarity rather than exact matches, powering semantic search and AI applications.Voir la définition complète → using the Responses APIAPIApplication Programming Interface: a standardised interface that lets applications communicate and exchange data without knowing each other's internal workings.Voir la définition complète →.

The pattern: upload your documents into a vector storevector storeA vector database stores data as high-dimensional numeric vectors (embeddings) and retrieves items by similarity rather than exact matches, powering semantic search and AI applications.Voir la définition complète → once, then attach that store as a tool. The model retrieves and cites automatically, just like a Connector does in the UI, but now it is in your product.

from openai import OpenAI

client = OpenAI()

# 1. Create a vector store and add your internal docs.
store = client.vector_stores.create(name="internal-policy-docs")
client.vector_stores.files.upload_and_poll(
    vector_store_id=store.id,
    file=open("Pricing_Policy_2026.pdf", "rb"),
)

# 2. Ask a grounded question; the model searches the store and cites sources.
response = client.responses.create(
    model="gpt-4.1",
    input="What's our discount cap for multi-year deals?",
    tools=[{"type": "file_search", "vector_store_ids": [store.id]}],
)

print(response.output_text)

That file_search tool is the same idea as a Connector: retrieval is hosted, you just point at the data. The full reference lives at platform.openai.com/docs.

The trade-off is responsibility. In the APIAPIApplication Programming Interface: a standardised interface that lets applications communicate and exchange data without knowing each other's internal workings.Voir la définition complète →, you enforce who can query which vector storevector storeA vector database stores data as high-dimensional numeric vectors (embeddings) and retrieves items by similarity rather than exact matches, powering semantic search and AI applications.Voir la définition complète →. There is no inherited Google permission protecting a document; if a user can hit your endpoint, they can search what you attached. So in your own app you must build the access control that the ChatGPT connector gave you for free.

Practical limits and gotchas

A few things to know before you rely on this in production:

• Freshness has a lag. Synced connectors re-index on a schedule. A file edited two minutes ago may not be reflected instantly. For "must be live" data, an Action that hits the source APIAPIApplication Programming Interface: a standardised interface that lets applications communicate and exchange data without knowing each other's internal workings.Voir la définition complète → is more appropriate than a synced connector.
• Format matters. Clean text-based docs (Google Docs, well-structured PDFs) retrieve far better than scanned images or dense slide decks. Garbage layout in, weak retrieval out.
• Citations are your QA tool. Always ask for citations on high-stakes answers and click them. The model can still phrase a synthesis loosely even when the underlying source is correct.
• Admin governance is real. On Enterprise, an admin decides which connectors exist at all. If Google Drive is not in your Connectors list, that is policy, not a bug. Check with your workspace admin.
• Scope tightly. Connecting "all of Drive" makes retrieval noisier. Connecting a specific, curated folder gives sharper, more relevant answers.

A quick decision guide

Use this to pick the right tool:

• One file, one question, today: upload it.
• A body of knowledge you'll query repeatedly: Connector, ideally inside a Project.
• A shared, standardized internal assistant for a team: Custom GPT with a connector.
• Live data or taking an action in another system: Action.
• The same grounded behavior inside your own software: Responses API with `file_search`.

Key Takeaways

• Connectors ground ChatGPT in your own tools (Drive, SharePoint, GitHub) and answer with clickable citations, so you can verify every claim against the source.
• A connector inherits your permissions and never elevates them. ChatGPT sees only what your account already can. Scope to specific folders for sharper, safer retrieval.
• Connectors read knowledge; Actions call APIs. ReachReachThe number of unique people exposed to your message in a given period. Unlike impressions, reach counts each person once, no matter how often they see it.Voir la définition complète → for a Connector to answer "what does our doc say," and an Action to fetch live data or do something.
• Put connectors inside Projects or Custom GPTs to fix the source of truth for a recurring workflow or a whole team, instead of re-uploading files each time.
• When you outgrow the UI, the API equivalent is `file_search` over a vector store via the Responses APIAPI. You gain control and lose the inherited permissions, so you must build access control yourself.