Email context your agent can actually use

One API call. Decisions, tasks, owners, and next steps from real email conversations.

Most agents break the moment you give them email.

Threads are messy. Replies duplicate everything. Decisions are buried across 20 messages. Attachments get referenced but live somewhere else.

So instead of "what happened in this deal?", your agent gets raw text and confidently wrong answers.

iGPT fixes that layer. You connect an inbox, ask a question, and get back structured answers your agent can actually use. No MIME parsing. No thread reconstruction. No attachment handling. Just a prompt, a schema, and a response your code can use.

Supported providers: Gmail, Outlook, and any IMAP provider. Multi-provider per user supported.

What you get back

Not summaries. Structured answers your agent can build on.

Ask: "What's unresolved with Northstar Logistics?"

{
  "open_items": [
    {
      "type": "commitment",
      "description": "Send completed security questionnaire",
      "owner": "us",
      "promised_on": "2026-03-05",
      "status": "overdue",
      "source": "email from David Park, March 5"
    },
    {
      "type": "unanswered_question",
      "description": "Data residency requirements for EU operations",
      "raised_by": "Northstar legal team",
      "date": "2026-02-28",
      "status": "open"
    }
  ],
  "attachments_referenced": ["Security_Audit_v2.pdf", "Q3_Rollout_Draft.xlsx"],
  "relationship_summary": "Active prospect for 4 months. Two open commitments from our side are overdue."
}

Every field is schema-validated. Every finding cites the source email thread. Typical response time: ~3 seconds, even across large inboxes.

Quick start

from igptai import IGPT

igpt = IGPT(api_key="IGPT_API_KEY", user="user_123")

res = igpt.recall.ask(
    input="Open action items from this week with owners and due dates",
    output_format={
        "strict": True,
        "schema": {
            "type": "object",
            "properties": {
                "action_items": {
                    "type": "array",
                    "items": {
                        "type": "object",
                        "properties": {
                            "title": {"type": "string"},
                            "owner": {"type": "string"},
                            "due_date": {"type": "string"}
                        }
                    }
                }
            }
        }
    }
)

pip install igptai        # Python
npm install igptai        # Node.js

Get your API key at igpt.ai/hub/apikeys or try queries in the Playground first.

What you can build

• Detect deals going cold before your CRM shows anything
• Keep your CRM in sync with what actually happened in email, not what someone remembered to log
• Extract tasks with correct owners and due dates into Jira, Asana, or Notion
• Build meeting prep agents that pull full relationship history, open commitments, and known concerns
• Score customer health from email response time, tone shifts, and engagement signals
• Surface threads waiting for a reply where someone asked a question and never got an answer

Why email is hard for agents

Email threads contain 4-5x duplicate content from nested quoting. Participants are buried in headers with no way to tell who committed to something versus who was just CC'd. Attachments get referenced in conversation ("see the numbers in row 17") but live in a completely separate data layer that most integrations ignore entirely.

Most teams end up building their own MIME parser, thread reconstruction logic, deduplication pipeline, and permission model before writing a single line of agent logic. iGPT handles all of that in one API call.

How it works

Connect an email account via OAuth → Ask with natural language or a JSON schema → Get back structured, cited results.

What iGPT handles under the hood: thread parsing, quoted text deduplication, participant role detection, attachment extraction, source citations, per-user data isolation.

Connect an email account

from igptai import IGPT

igpt = IGPT(api_key="IGPT_API_KEY")

res = igpt.connectors.authorize(user="user_123", service="spike", scope="messages")
print("Open this URL to authorize:", res.get("url"))

Ask with structured output

igpt = IGPT(api_key="IGPT_API_KEY", user="user_123")

res = igpt.recall.ask(
    input="Extract key risks, decisions, and next steps from this week.",
    output_format={
        "strict": True,
        "schema": {
            "type": "object",
            "properties": {
                "risks": {"type": "array", "items": {"type": "string"}},
                "decisions": {"type": "array", "items": {"type": "string"}},
                "next_steps": {
                    "type": "array",
                    "items": {
                        "type": "object",
                        "properties": {
                            "action": {"type": "string"},
                            "owner": {"type": "string"},
                            "due_date": {"type": "string"}
                        }
                    }
                }
            }
        }
    }
)

Search across email

res = igpt.recall.search(
    query="Q1 budget discussion",
    date_from="2026-01-01",
    date_to="2026-03-31"
)

🔒 Security

iGPT operates on sensitive communication data. Security is enforced by architecture, not assumptions.

• Per-user isolation — Each user's datasources, indexes, and context are physically separated, not filtered.
• Encryption — AES encryption at rest and in transit. HTTPS only.
• No prompt retention — Prompts and generated outputs are discarded after execution.
• Controlled execution — Deterministic pipelines prevent prompt injection.
• Auditability — Every request produces metadata for tracing without logging raw content.

For the full security model, see docs.igpt.ai/docs/security.

More examples

import IGPT from "igptai";

const igpt = new IGPT({ apiKey: process.env.IGPT_API_KEY, user: "user_123" });

const res = await igpt.recall.ask({
  input: "List open action items from this week. Include owner and due date."
});

console.log(res);

stream = igpt.recall.ask(input="Stream the answer in chunks.", stream=True)
for chunk in stream:
    print(chunk)

res = igpt.recall.ask(input="...")
if res is not None and res.get("error"):
    print("Error:", res["error"])
else:
    print(res)

🔗 Related

• iGPT Python SDK — pip install igptai
• iGPT Node.js SDK — npm install igptai
• iGPT Sales Skills — 7 ready-made sales workflows
• API Documentation — Full endpoint reference
• Playground — Try queries interactively before writing code
• Get API Key — Create your key and start building

Contributing

Questions, bugs, or feature requests? Open an issue or reach out at [email protected].

License

MIT