DEV Community: Emmanuel Onwuegbusi

How to build a pitch deck triage agent with LangGraph and Nango

Emmanuel Onwuegbusi — Mon, 07 Sep 2026 12:51:36 +0000

In this guide you will build an AI agent that reads pitch-deck emails from Gmail, judges each deck against a fixed investment thesis with an LLM, and posts a Slack message when a deck is a fit. LangGraph orchestrates the steps; Nango handles the Gmail and Slack connections and exposes them to the graph over MCP.

By the end you will have:

Three Nango actions - search Gmail for pitch-deck emails, download an attachment, post to Slack - deployed and callable.
A LangGraph pipeline that runs those actions in a fixed order and, in between, asks OpenAI for a { fit, reasoning, evidenceQuote } verdict grounded in a real quote from the deck.
A working end-to-end run: email a PDF to yourself, run one command, get a Slack message.

Why is it hard to build a pipeline like this?

You need two separate OAuth integrations - Gmail and Slack - each with its own token lifecycle, scopes, and refresh flow. Get either wrong and the pipeline fails days later when a token expires, not on your first test.

Gmail's API does not hand you a pitch deck in one call. Searching an inbox returns message metadata; getting an attachment's bytes is a second request keyed off an attachmentId from the first. And Gmail returns those bytes base64url-encoded, not standard base64, so a naive decode produces a broken PDF.

Then there's the LLM. It's easy to get a model to say "yes, this fits". It's harder to make it say why, and prove the why by quoting the actual document rather than paraphrasing something half-remembered from the prompt.

Why use Nango for this

Nango gives you the OAuth flow, token storage, and refresh logic for Gmail and Slack out of the box. You connect an account once in a hosted popup; every call after that carries a valid token without your code touching it.

You write the provider logic as small server-side functions called actions - input schema, output schema, and an exec body. Deploy one and it's a versioned endpoint, and Nango automatically exposes it as a tool on its hosted MCP server at https://api.nango.dev/mcp. Your graph calls those tools by name; no model ever picks them.

Outline

Sign up for Nango and get your secret key
Add the Gmail and Slack integrations
Connect your Gmail and Slack accounts
Scaffold the Nango integration folder
Write the list-pitch-emails action
Write the fetch-attachment action
Write the send-slack-message action
Deploy the actions to Nango
Set up the LangGraph project
Add the thesis, MCP client, PDF, and assessment files
Build the LangGraph pipeline
Write the entry point
Generate sample pitch decks
Run a Triage Run
Common issues
Conclusion

Sign up for Nango and get your secret key

Go to app.nango.dev/signup and create a free account.

Once you're in, open Environment settings in the left sidebar, select the API Keys tab, and copy the key for the dev environment. You'll use this same value in two places later: NANGO_SECRET_KEY_DEV for the CLI, and NANGO_SECRET_KEY for the graph.

Add the Gmail and Slack integrations

An integration is a provider (Gmail, Slack) plus its OAuth app. Nango ships a shared dev OAuth app for each, so you don't have to register your own.

Left sidebar → Integrations → Set up new integration.
Search Gmail and select it.
On the Nango developer app tab, leave the pre-filled Client ID / Secret / Scopes as they are and click Create.

Repeat for Slack. When both exist, your Integrations list looks like this - note the IDs google-mail and slack, which you'll pass to the graph later:

Connect your Gmail and Slack accounts

Each integration now needs one authorized connection.

Open the Gmail integration → click Add test connection.
Click Authorize, and complete the Google popup.

Do the same on the Slack integration. When you authorize Slack, pick (or create) the channel you want notifications in - for example #pitch-triage - and make sure the Nango app is a member of it.

Copy both connection IDs from the Connections tab. You now have: a Nango secret key, a Gmail connection ID, and a Slack connection ID.

Scaffold the Nango integration folder

Create the project and an integration folder for the Nango actions:

mkdir -p pitch-deck-triage-agent/integration/.nango
cd pitch-deck-triage-agent/integration

Create package.json:

{
  "name": "nango-integrations",
  "version": "1.0.0",
  "private": true,
  "type": "module",
  "engines": { "node": ">=22.22.2" },
  "scripts": { "compile": "nango compile", "dev": "nango dev" },
  "devDependencies": { "nango": "0.71.6", "zod": "4.3.6" }
}

Install:

npm install

Create tsconfig.json (Nango uses this to type-check your actions):

{
  "$schema": "https://json.schemastore.org/tsconfig",
  "include": ["index.ts", "**/*.ts"],
  "exclude": ["node_modules", "dist", "build", ".nango"],
  "compilerOptions": {
    "module": "node16",
    "target": "esnext",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "moduleResolution": "node16",
    "exactOptionalPropertyTypes": true,
    "noUncheckedIndexedAccess": true,
    "noUnusedLocals": true,
    "noUnusedParameters": true,
    "noEmit": true
  }
}

Create index.ts - it just imports every action so Nango picks them up (note the .js extension even though the files are .ts; that's the Node 16 module convention Nango uses):

import './google-mail/actions/list-pitch-emails.js';
import './google-mail/actions/fetch-attachment.js';
import './slack/actions/send-slack-message.js';

Create .env with the dev secret key you copied earlier:

NANGO_SECRET_KEY_DEV=your-nango-dev-secret-key

Write the `list-pitch-emails` action

This action searches Gmail for recent messages with a PDF attachment and returns one candidate per message - metadata plus an attachmentId, not the file itself (Gmail won't give you both in one call).

Create google-mail/actions/list-pitch-emails.ts:

import { createAction } from 'nango';
import * as z from 'zod';

// Input is z.object({}).strict(), not z.void(): Nango compiles `void` to a
// {"type":"null"} schema, but an MCP tools/call sends `arguments` as an
// object ({} for a no-input tool), which fails that schema. See Common issues.

const QUERY = 'has:attachment filename:pdf newer_than:30d';
const MAX_RESULTS = 5;

const outputSchema = z.object({
    candidates: z.array(
        z.object({
            messageId: z.string(),
            threadId: z.string(),
            from: z.string(),
            subject: z.string(),
            attachmentId: z.string(),
            filename: z.string()
        })
    )
});

interface GmailHeader {
    name: string;
    value: string;
}

interface GmailPart {
    mimeType?: string;
    filename?: string;
    body?: { attachmentId?: string; size?: number };
    parts?: GmailPart[];
}

interface GmailMessage {
    id: string;
    threadId: string;
    payload?: GmailPart & { headers?: GmailHeader[] };
}

interface GmailListResponse {
    messages?: { id: string; threadId: string }[];
}

function findPdfAttachment(part: GmailPart | undefined): { attachmentId: string; filename: string } | undefined {
    if (!part) {
        return undefined;
    }
    if (part.mimeType === 'application/pdf' && part.body?.attachmentId) {
        return { attachmentId: part.body.attachmentId, filename: part.filename || 'deck.pdf' };
    }
    for (const child of part.parts ?? []) {
        const found = findPdfAttachment(child);
        if (found) {
            return found;
        }
    }
    return undefined;
}

function header(headers: GmailHeader[] | undefined, name: string): string {
    return headers?.find((h) => h.name.toLowerCase() === name.toLowerCase())?.value ?? '';
}

const action = createAction({
    description: 'List recent Gmail messages that have a PDF attachment, one candidate Pitch Deck per message.',
    version: '1.0.0',
    endpoint: { method: 'GET', path: '/gmail/pitch-emails', group: 'Triage' },
    input: z.object({}).strict(),
    output: outputSchema,

    exec: async (nango): Promise<z.infer<typeof outputSchema>> => {
        const listRes = await nango.get<GmailListResponse>({
            endpoint: '/gmail/v1/users/me/messages',
            params: { q: QUERY, maxResults: String(MAX_RESULTS) }
        });

        const candidates: z.infer<typeof outputSchema>['candidates'] = [];
        for (const { id } of listRes.data.messages ?? []) {
            const msgRes = await nango.get<GmailMessage>({
                endpoint: `/gmail/v1/users/me/messages/${id}`,
                params: { format: 'full' }
            });

            const attachment = findPdfAttachment(msgRes.data.payload);
            if (!attachment) {
                continue;
            }

            candidates.push({
                messageId: msgRes.data.id,
                threadId: msgRes.data.threadId,
                from: header(msgRes.data.payload?.headers, 'From'),
                subject: header(msgRes.data.payload?.headers, 'Subject'),
                attachmentId: attachment.attachmentId,
                filename: attachment.filename
            });
        }

        return { candidates };
    }
});

export type NangoActionLocal = Parameters<(typeof action)['exec']>[0];
export default action;

Inside exec, nango.get calls the real Gmail API with the connection's token attached for you. You never see a token.

Write the `fetch-attachment` action

Given the messageId and attachmentId from the first action, this one downloads the attachment's bytes.

Create google-mail/actions/fetch-attachment.ts:

import { createAction } from 'nango';
import * as z from 'zod';

const inputSchema = z.object({
    messageId: z.string().min(1),
    attachmentId: z.string().min(1)
});

const outputSchema = z.object({
    // Gmail returns this base64url-encoded (- and _ instead of + and /),
    // not standard base64. The caller converts before decoding.
    data: z.string(),
    size: z.number()
});

interface GmailAttachmentResponse {
    data: string;
    size: number;
}

const action = createAction({
    description: "Fetch the raw content of one Gmail attachment (base64url-encoded, as Gmail's API returns it).",
    version: '1.0.0',
    endpoint: { method: 'GET', path: '/gmail/attachment', group: 'Triage' },
    input: inputSchema,
    output: outputSchema,

    exec: async (nango, input): Promise<z.infer<typeof outputSchema>> => {
        const res = await nango.get<GmailAttachmentResponse>({
            endpoint: `/gmail/v1/users/me/messages/${input.messageId}/attachments/${input.attachmentId}`
        });

        return { data: res.data.data, size: res.data.size };
    }
});

export type NangoActionLocal = Parameters<(typeof action)['exec']>[0];
export default action;

Write the `send-slack-message` action

This one posts to Slack's chat.postMessage. Slack answers HTTP 200 even when a post fails, with the real error in { ok: false, error } - Nango's retry logic keys off status codes and never sees that, so the action checks ok itself.

Create slack/actions/send-slack-message.ts:

import { createAction } from 'nango';
import * as z from 'zod';

const inputSchema = z.object({
    channel: z.string().min(1).describe('Slack channel ID or name (e.g. "#pitch-triage")'),
    text: z.string().min(1)
});

const outputSchema = z.object({
    channel: z.string(),
    ts: z.string()
});

interface SlackPostMessageResponse {
    ok: boolean;
    error?: string;
    channel?: string;
    ts?: string;
}

const action = createAction({
    description: 'Post a message to a Slack channel.',
    version: '1.0.0',
    endpoint: { method: 'POST', path: '/slack/messages', group: 'Triage' },
    input: inputSchema,
    output: outputSchema,

    exec: async (nango, input): Promise<z.infer<typeof outputSchema>> => {
        const res = await nango.post<SlackPostMessageResponse>({
            endpoint: '/chat.postMessage',
            retries: 0,
            data: { channel: input.channel, text: input.text }
        });

        if (!res.data.ok || !res.data.ts || !res.data.channel) {
            throw new nango.ActionError({ message: `Slack chat.postMessage failed: ${res.data.error ?? 'unknown error'}` });
        }

        return { channel: res.data.channel, ts: res.data.ts };
    }
});

export type NangoActionLocal = Parameters<(typeof action)['exec']>[0];
export default action;

Deploy the actions to Nango

From the integration folder:

npx nango deploy dev

Nango type-checks and uploads all three actions in one go:

Check the Functions tab on each integration in the dashboard. Gmail shows list-pitch-emails and fetch-attachment:

Slack shows send-slack-message:

Each deployed action is now also a tool on Nango's MCP server. That's what the graph calls next.

Set up the LangGraph project

Back at the project root, create a graph folder for the pipeline:

cd ..
mkdir -p graph/src
cd graph

Create package.json:

{
  "name": "pitch-deck-triage-graph",
  "version": "1.0.0",
  "private": true,
  "type": "module",
  "engines": { "node": ">=22" },
  "scripts": {
    "triage": "tsx src/run.ts",
    "generate-decks": "tsx src/generate-decks.ts"
  },
  "dependencies": {
    "@langchain/langgraph": "^0.2.57",
    "dotenv": "^16.4.5",
    "openai": "^4.104.0",
    "pdfjs-dist": "^6.3.289"
  },
  "devDependencies": {
    "@types/node": "^22.9.0",
    "@types/pdfkit": "^0.13.4",
    "pdfkit": "^0.15.1",
    "tsx": "^4.19.2",
    "typescript": "^5.6.3"
  }
}

Install:

npm install

Create tsconfig.json:

{
  "compilerOptions": {
    "target": "es2022",
    "module": "node16",
    "moduleResolution": "node16",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "noEmit": true,
    "allowImportingTsExtensions": true,
    "types": ["node"]
  },
  "include": ["src/**/*.ts"]
}

Create .env with the values you gathered earlier (NANGO_SECRET_KEY is the same dev key as NANGO_SECRET_KEY_DEV):

OPENAI_API_KEY=your-openai-key
NANGO_SECRET_KEY=your-nango-dev-secret-key
NANGO_GMAIL_CONNECTION_ID=your-gmail-connection-id
NANGO_SLACK_CONNECTION_ID=your-slack-connection-id
SLACK_CHANNEL="#pitch-triage"

Quote SLACK_CHANNEL if it starts with # - dotenv treats an unquoted # as a comment and drops the rest of the line.

Add the thesis, MCP client, PDF, and assessment files

Four small src/ files the pipeline depends on.

src/thesis.ts - the fixed rule every deck is judged against. Edit it to match a real thesis if you like; this one is fabricated.

export const THESIS = `Acme Ventures invests in seed-stage, developer-focused B2B software companies.

We look for:
- US or EU-incorporated companies
- A product built for a technical buyer (developers, DevOps, IT, or security teams)
- $0-$2M in current ARR
- At least one technical co-founder who still writes code
- A believable path to $1M ARR within 12 months of this round

We do not invest in consumer apps, hardware, life sciences, gaming, or crypto/token-based businesses, regardless of traction.`;

src/mcp-client.ts - a ~100-line client (no SDK) that calls one named tool on Nango's MCP server. It does the MCP handshake (initialize, then notifications/initialized, then tools/call) and unwraps the result. Each call carries three headers so Nango knows which account to use: your secret key, the connection-id, and the provider-config-key (google-mail or slack).

const NANGO_MCP_URL = 'https://api.nango.dev/mcp';

export interface McpScope {
    connectionId: string;
    providerConfigKey: string;
}

interface JsonRpcResponse {
    jsonrpc: '2.0';
    id?: number;
    result?: unknown;
    error?: { code: number; message: string; data?: unknown };
}

interface McpToolResult {
    isError?: boolean;
    content?: { type: string; text?: string }[];
}

function headersFor(secretKey: string, scope: McpScope): Record<string, string> {
    return {
        'Content-Type': 'application/json',
        Accept: 'application/json, text/event-stream',
        Authorization: `Bearer ${secretKey}`,
        'connection-id': scope.connectionId,
        'provider-config-key': scope.providerConfigKey
    };
}

async function parseBody(res: Response): Promise<JsonRpcResponse | undefined> {
    const contentType = res.headers.get('content-type') ?? '';
    const body = await res.text();
    if (!body) {
        return undefined;
    }

    if (contentType.includes('text/event-stream')) {
        // SSE framing: one or more "data: <json>" lines; take the last.
        const dataLines = body
            .split('\n')
            .filter((line) => line.startsWith('data:'))
            .map((line) => line.slice('data:'.length).trim());
        const last = dataLines.at(-1);
        return last ? (JSON.parse(last) as JsonRpcResponse) : undefined;
    }

    return JSON.parse(body) as JsonRpcResponse;
}

let nextId = 1;

async function rpc(headers: Record<string, string>, method: string, params?: unknown): Promise<unknown> {
    const res = await fetch(NANGO_MCP_URL, {
        method: 'POST',
        headers,
        body: JSON.stringify({ jsonrpc: '2.0', id: nextId++, method, params })
    });
    if (!res.ok) {
        throw new Error(`MCP ${method} failed: HTTP ${res.status} ${await res.text()}`);
    }
    const parsed = await parseBody(res);
    if (parsed?.error) {
        throw new Error(`MCP ${method} error: ${JSON.stringify(parsed.error)}`);
    }
    return parsed?.result;
}

export async function callNangoTool<T = unknown>(secretKey: string, scope: McpScope, toolName: string, args: Record<string, unknown>): Promise<T> {
    const headers = headersFor(secretKey, scope);

    await rpc(headers, 'initialize', {
        protocolVersion: '2025-03-26',
        capabilities: {},
        clientInfo: { name: 'pitch-deck-triage-graph', version: '1.0.0' }
    });

    // Required notification - no response expected, fire and ignore.
    await fetch(NANGO_MCP_URL, {
        method: 'POST',
        headers,
        body: JSON.stringify({ jsonrpc: '2.0', method: 'notifications/initialized' })
    }).catch(() => undefined);

    const result = (await rpc(headers, 'tools/call', { name: toolName, arguments: args })) as McpToolResult | undefined;

    if (result?.isError) {
        throw new Error(`Nango tool "${toolName}" failed: ${JSON.stringify(result.content)}`);
    }

    const textBlock = result?.content?.find((c) => c.type === 'text' && typeof c.text === 'string');
    if (!textBlock?.text) {
        throw new Error(`Nango tool "${toolName}" returned no text content: ${JSON.stringify(result)}`);
    }
    return JSON.parse(textBlock.text) as T;
}

src/pdf.ts - turns the base64url bytes from fetch-attachment into plain text. It uses pdfjs-dist directly (the older pdf-parse package chokes on PDFs from a current pdfkit). Text only, no OCR - an image-only deck comes back empty.

import { getDocument } from 'pdfjs-dist/legacy/build/pdf.mjs';

interface TextItem {
    str?: string;
}

type GetDocumentParams = Parameters<typeof getDocument>[0];

export async function extractPdfText(base64UrlData: string): Promise<string> {
    const base64 = base64UrlData.replace(/-/g, '+').replace(/_/g, '/');
    const buffer = Buffer.from(base64, 'base64');

    // disableWorker isn't in this version's types but works at runtime.
    const params = {
        data: new Uint8Array(buffer),
        disableWorker: true
    } as unknown as GetDocumentParams;
    const doc = await getDocument(params).promise;
    const pages: string[] = [];
    for (let pageNum = 1; pageNum <= doc.numPages; pageNum++) {
        const page = await doc.getPage(pageNum);
        const content = await page.getTextContent();
        const text = content.items.map((item) => (item as TextItem).str ?? '').join(' ');
        pages.push(text);
    }

    return pages.join('\n\n').trim();
}

src/assess.ts - the only LLM call in the whole project. One OpenAI Structured Outputs call returns { fit, reasoning, evidenceQuote }. The schema forces evidenceQuote to be one contiguous span from the deck - without that, the model stitched two non-adjacent sentences together with "..." and called it a quote.

import type OpenAI from 'openai';

export interface FitAssessment {
    fit: boolean;
    reasoning: string;
    evidenceQuote: string;
}

const SCHEMA = {
    type: 'object',
    properties: {
        fit: { type: 'boolean', description: 'True if the deck matches the thesis, false otherwise.' },
        reasoning: { type: 'string', description: 'One or two sentences explaining the fit/no-fit call.' },
        evidenceQuote: {
            type: 'string',
            description:
                "A single contiguous verbatim span copied from the deck's text (a sentence or clause, not several stitched together with '...') that the reasoning is grounded in."
        }
    },
    required: ['fit', 'reasoning', 'evidenceQuote'],
    additionalProperties: false
} as const;

export async function assessFit(openai: OpenAI, thesis: string, deckText: string): Promise<FitAssessment> {
    const response = await openai.responses.create({
        model: 'gpt-4.1', // pin the current model at build time
        input: [
            {
                role: 'system',
                content:
                    "You triage pitch decks against a fixed investment thesis. Judge only what the deck's text actually says - don't assume anything it doesn't state. Ground your reasoning in one short, verbatim quote from the deck: a single contiguous span copied exactly as written, never several sentences stitched together with '...'."
            },
            {
                role: 'user',
                content: `Thesis:\n${thesis}\n\nPitch deck text:\n${deckText}`
            }
        ],
        text: {
            format: {
                type: 'json_schema',
                name: 'fit_assessment',
                schema: SCHEMA,
                strict: true
            }
        }
    });

    return JSON.parse(response.output_text) as FitAssessment;
}

Build the LangGraph pipeline

Now the graph itself. Four nodes in a line, with two exits: stop if no candidate email, stop if the deck doesn't fit. No model chooses tools - each node calls one named Nango tool.

Create src/pipeline.ts:

import { StateGraph, Annotation, START, END } from '@langchain/langgraph';
import type OpenAI from 'openai';
import { callNangoTool } from './mcp-client.ts';
import { extractPdfText } from './pdf.ts';
import { assessFit, type FitAssessment } from './assess.ts';
import { THESIS } from './thesis.ts';

interface EmailCandidate {
    messageId: string;
    threadId: string;
    from: string;
    subject: string;
    attachmentId: string;
    filename: string;
}

const TriageState = Annotation.Root({
    email: Annotation<EmailCandidate | null>({ reducer: (_prev, next) => next, default: () => null }),
    deckText: Annotation<string | null>({ reducer: (_prev, next) => next, default: () => null }),
    assessment: Annotation<FitAssessment | null>({ reducer: (_prev, next) => next, default: () => null }),
    notified: Annotation<boolean>({ reducer: (_prev, next) => next, default: () => false })
});

export interface GraphConfig {
    nangoSecretKey: string;
    gmailConnectionId: string;
    slackConnectionId: string;
    slackChannel: string;
    openai: OpenAI;
}

export function buildTriageGraph(config: GraphConfig) {
    const gmailScope = { connectionId: config.gmailConnectionId, providerConfigKey: 'google-mail' };
    const slackScope = { connectionId: config.slackConnectionId, providerConfigKey: 'slack' };

    const graph = new StateGraph(TriageState)
        .addNode('fetchEmail', async () => {
            const { candidates } = await callNangoTool<{ candidates: EmailCandidate[] }>(config.nangoSecretKey, gmailScope, 'list-pitch-emails', {});
            const email = candidates[0] ?? null;
            if (!email) {
                console.log('No candidate Pitch Deck email found - nothing to triage this run.');
            }
            return { email };
        })
        .addNode('fetchDeck', async (state) => {
            if (!state.email) {
                return {};
            }
            const { data } = await callNangoTool<{ data: string; size: number }>(config.nangoSecretKey, gmailScope, 'fetch-attachment', {
                messageId: state.email.messageId,
                attachmentId: state.email.attachmentId
            });
            const deckText = await extractPdfText(data);
            return { deckText };
        })
        .addNode('assess', async (state) => {
            if (!state.deckText) {
                return {};
            }
            const assessment = await assessFit(config.openai, THESIS, state.deckText);
            return { assessment };
        })
        .addNode('notify', async (state) => {
            if (!state.email || !state.assessment) {
                return {};
            }
            const text =
                `*Pitch deck fit* — ${state.email.subject} (from ${state.email.from})\n` +
                `Fit: ${state.assessment.fit ? '✅ yes' : '❌ no'}\n` +
                `Reasoning: ${state.assessment.reasoning}\n` +
                `> ${state.assessment.evidenceQuote}`;
            await callNangoTool(config.nangoSecretKey, slackScope, 'send-slack-message', { channel: config.slackChannel, text });
            return { notified: true };
        })
        .addEdge(START, 'fetchEmail')
        .addConditionalEdges('fetchEmail', (state) => (state.email ? 'fetchDeck' : END), { fetchDeck: 'fetchDeck', [END]: END })
        .addEdge('fetchDeck', 'assess')
        .addConditionalEdges('assess', (state) => (state.assessment?.fit ? 'notify' : END), { notify: 'notify', [END]: END })
        .addEdge('notify', END);

    return graph.compile();
}

Write the entry point

Create src/run.ts - it reads the .env, builds the graph, and runs it once:

import 'dotenv/config';
import OpenAI from 'openai';
import { buildTriageGraph } from './pipeline.ts';

function requireEnv(name: string): string {
    const v = process.env[name];
    if (!v) {
        throw new Error(`Missing env var ${name} - see .env.example`);
    }
    return v;
}

const openai = new OpenAI({ apiKey: requireEnv('OPENAI_API_KEY') });

const graph = buildTriageGraph({
    nangoSecretKey: requireEnv('NANGO_SECRET_KEY'),
    gmailConnectionId: requireEnv('NANGO_GMAIL_CONNECTION_ID'),
    slackConnectionId: requireEnv('NANGO_SLACK_CONNECTION_ID'),
    slackChannel: requireEnv('SLACK_CHANNEL'),
    openai
});

const started = Date.now();
const result = await graph.invoke({});
const elapsed = Date.now() - started;

console.log(`\n--- Triage Run (${elapsed} ms) ---`);
console.log(JSON.stringify(result, null, 2));

Generate sample pitch decks

You need PDFs to test with. Create src/generate-decks.ts - it writes three fabricated decks (one that fits the thesis, two that don't):

import PDFDocument from 'pdfkit';
import { createWriteStream, mkdirSync } from 'node:fs';
import { join, dirname } from 'node:path';
import { fileURLToPath } from 'node:url';

const __dirname = dirname(fileURLToPath(import.meta.url));
const OUT_DIR = join(__dirname, '..', '..', 'decks');

interface Deck {
    filename: string;
    lines: string[];
}

const DECKS: Deck[] = [
    {
        filename: 'quantumleap-fit.pdf',
        lines: [
            'QuantumLeap Analytics',
            'Observability for backend engineers, not SREs on-call at 3am.',
            '',
            'Problem: mid-size engineering teams drown in dashboards but still get paged for issues nobody can explain.',
            'Solution: a query-log-first observability tool built directly into the deploy pipeline, no agent to babysit.',
            '',
            'Team: two co-founders, both ex-Datadog engineers, both still write the core query engine.',
            'Traction: $380K ARR across 14 mid-market engineering teams, up from $90K six months ago.',
            'Ask: raising a $2.5M seed to hire 2 engineers and close a pipeline of 6 enterprise pilots we believe gets us to $1.1M ARR within 12 months.',
            'Incorporated: Delaware C-corp, HQ in Austin, TX.'
        ]
    },
    {
        filename: 'fieldnote-no-fit-consumer.pdf',
        lines: [
            'Fieldnote',
            'A daily journaling app that turns your mood into a photo memory.',
            '',
            'Problem: people want to reflect on their day but journaling apps feel like homework.',
            'Solution: a 10-second voice note becomes a journal entry with an AI-generated photo of your mood.',
            '',
            'Team: one founder, background in product design at a consumer social app.',
            'Traction: 40,000 downloads, 3,200 weekly active users, freemium with a $4.99/mo tier.',
            'Ask: raising a $1.5M pre-seed to grow to 250,000 downloads via TikTok creator partnerships.',
            'Incorporated: Delaware C-corp, HQ in Los Angeles, CA.'
        ]
    },
    {
        filename: 'brightforge-no-fit-hardware.pdf',
        lines: [
            'BrightForge Robotics',
            'Autonomous forklifts for mid-size warehouses.',
            '',
            "Problem: mid-size warehouses can't justify a full automation retrofit, so they stay manual and understaffed.",
            'Solution: a retrofit kit that turns an existing forklift into an autonomous unit in under a day.',
            '',
            'Team: two mechanical engineers, one ex-Boston Dynamics, one ex-Zoox.',
            'Traction: 3 warehouse pilots running, $210K in signed pilot revenue, hardware gross margin 38%.',
            'Ask: raising a $4M seed to build the next hardware revision and open a small assembly line.',
            'Incorporated: Delaware C-corp, HQ in Pittsburgh, PA.'
        ]
    }
];

mkdirSync(OUT_DIR, { recursive: true });

async function writeDeck(deck: Deck): Promise<void> {
    const outPath = join(OUT_DIR, deck.filename);
    const doc = new PDFDocument({ margin: 60 });
    const stream = createWriteStream(outPath);
    doc.pipe(stream);

    const [title, ...rest] = deck.lines;
    doc.fontSize(20).text(title ?? '', { underline: true });
    doc.moveDown();
    doc.fontSize(12);
    for (const line of rest) {
        if (line === '') {
            doc.moveDown();
        } else {
            doc.text(line);
        }
    }
    doc.end();

    // pdfkit flushes the trailer asynchronously - wait for the stream to
    // finish or the file is truncated.
    await new Promise<void>((resolve, reject) => {
        stream.on('finish', resolve);
        stream.on('error', reject);
    });
    console.log(`Wrote ${outPath}`);
}

for (const deck of DECKS) {
    await writeDeck(deck);
}

Run it:

npm run generate-decks

Three PDFs land in decks/ at the project root.

Run a Triage Run

Email decks/quantumleap-fit.pdf to the Gmail account you connected, as a PDF attachment. Any subject line.
From the graph folder:

npm run triage

The pipeline searches your inbox, downloads the PDF, extracts its text, asks OpenAI for a verdict, and - because this deck fits the thesis - posts to Slack:

The console prints the full state, including the assessment:

{
  "email": { "subject": "pitch deck", "from": "you@gmail.com", "filename": "quantumleap-fit.pdf", ... },
  "assessment": {
    "fit": true,
    "reasoning": "US incorporation, developer-focused B2B software, ARR in range, technical co-founders coding, clear path to $1M+ ARR in 12 months.",
    "evidenceQuote": "Team: two co-founders, both ex-Datadog engineers, both still write the core query engine."
  },
  "notified": true
}

Now email fieldnote-no-fit-consumer.pdf and run it again: same fetch and extract, but the assessment comes back fit: false ("a consumer journaling app, not B2B software for technical buyers"), the graph routes past notify, and no Slack message is sent.

Common issues

Issue	Cause and fix
`invalid_action_input: must be null` when a no-input action is called over MCP	Nango compiles a `z.void()` input schema to `{"type":"null"}`, but an MCP `tools/call` always sends `arguments` as an object (`{}` for a no-input tool), which fails that schema. Use `z.object({}).strict()` instead of `z.void()`.
`SLACK_CHANNEL` reads as empty despite being set in `.env`	`dotenv` treats an unquoted `#` as a comment marker and drops everything after it, so `SLACK_CHANNEL=#pitch-triage` becomes empty. Quote it: `SLACK_CHANNEL="#pitch-triage"`.
`nango deploy dev` removes actions from another project	`nango deploy` makes the environment match the folder you deploy from - it's scoped to the environment, not the folder. Deploying a second project against the same secret key can wipe the first project's actions. Use a separate Nango environment per project.
A run picks the wrong email when several are waiting	Gmail's `messages.list` order is not reliably newest-first. Code that takes `candidates[0]` can act on an older message while a newer one waits behind it. Sort or filter on `internalDate` rather than trusting order.
Running the same pipeline twice on one email sends two Slack messages	Nothing remembers what was already processed. A search-based trigger needs its own idempotency key, checked and stored somewhere durable, if re-runs shouldn't double-notify.
The extracted deck text is empty	The PDF has no text layer (it's a slide export of images). This pipeline is text-only, no OCR.

Conclusion

The pipeline is short because Nango absorbs the parts that usually aren't: two OAuth flows, token refresh, the base URL and auth header on every provider call, and a tool interface the graph can call without an SDK. What's left in your code is the actual triage logic - search, extract, judge, notify - and a fixed graph wiring it together.

The same shape works for any "read an inbox, judge it against a rule, tell a channel" task: support triage, lead routing, compliance review. Swap the thesis, the Gmail query, and the Slack text.

Full code: github.com/emmakodes/pitch-deck-triage-agent.

Built with Nango, LangGraph, and the OpenAI Structured Outputs API.

Build Your Own AI Agent that Can Browse the Web and Take Actions 🤖

Emmanuel Onwuegbusi — Fri, 09 May 2025 12:44:55 +0000

In this article, we'll explore how to build an AI agent that can automatically browse the web and perform actions using the Supercog Agentic Framework. This powerful agent combines browser automation with AI vision models to create an intelligent web assistant that can navigate websites, extract information, and perform tasks just like a human would.

Outline 📋

Installation
Set up Required API Keys
Running the OSS Operator Agent
Customizing the Agent
Conclusion

Installation 🛠️

Let's install the framework from source to get started:

# Clone the repository
git clone https://github.com/supercog-ai/agentic.git

# Change to the agentic directory
cd agentic

# Create and activate a virtual environment
python -m venv .venv
source .venv/bin/activate  # On Windows: .venv\Scripts\activate

# Install with browser-use dependencies
uv pip install -e ".[browser-use,dev]"

# Install Playwright browsers
playwright install

Set up Required API Keys 🔑

To use the OSS Operator Agent, you'll need to set up an API key for your chosen model:

Google Gemini API Key (Recommended):
- Sign up at Google AI Studio
- Create an API key
- We recommend using Gemini 2.0 Flash model which is optimized for browser automation tasks and has better context handling
OpenAI API Key (Alternative):
- Sign up at OpenAI
- Create an API key in your account settings
- Can be used with GPT-4 or other OpenAI models

You can set the key as an environment variable:

# For Gemini (recommended)
export GEMINI_API_KEY=your_gemini_key

# OR for OpenAI
export OPENAI_API_KEY=your_openai_key

Running the OSS Operator Agent 🚀

Navigate to the examples directory:

cd examples

Run the OSS operator agent:

python oss_operator.py

The agent will start and you can interact with it through the command line. Try asking it to:
- Get the first 5 posts from Hacker News homepage
- Search for specific information on a website
- Fill out forms or perform actions on websites

Example interaction:

I am your open source Operator. What task would you like me to perform?
> get me the first 5 posts on hackernews homepage

The agent will:

Open a browser window
Navigate to Hacker News
Extract the first 5 posts
Return the results to you

Customizing the Agent 🎯

You can customize the agent by modifying the oss_operator.py file:

Choose Your Model: The agent supports different AI models:

agent = Agent(
    name="OSS Operator",
    model="gemini/gemini-2.0-flash",  # Recommended for browser automation
    # Other options:
    # model="openai/gpt-4o"
    # model="openai/gpt-4"
    tools=[BrowserUseTool()]
)

Use Your Browser: You can configure the agent to use your actual Chrome browser instance (with your cookies and state):

BrowserUseTool(
    chrome_instance_path='/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',  # MacOS
    # For Windows: 'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe'
    # For Linux: '/usr/bin/google-chrome'
)

Conclusion 🎉

The OSS Operator Agent demonstrates the power of combining browser automation with AI vision models. Using the Supercog Agentic Framework, you can create all kinds of sophisticated AI Agents just like the web automation agents that can understand and interact with websites in a human-like way.

Some exciting use cases:

Automated web research
Data collection and monitoring
Form filling and submission
Website testing
Content extraction
Automated workflows

To learn more about Supercog Agentic Framework:

Visit the GitHub repository: https://github.com/supercog-ai/agentic
Check out the documentation: https://supercog-ai.github.io/agentic/latest/
Join the Discord community: https://discord.gg/EmPGShjmGu

Don't forget to star the repository if you find it useful! ⭐

Troubleshooting 🔧

If you encounter any issues:

Browser Installation: Make sure Playwright is properly installed:

playwright install

API Key Issues: Verify your API keys are correctly set in the environment variables.
Model Selection: If you run into context limits, try using Gemini 2.0 Flash instead of GPT-4.
Browser Path: If using a custom Chrome instance, ensure the path is correct for your operating system.

Feel free to ask questions in the comments below or open an issue on GitHub if you need help!

Straightforward No-code Meeting Notetaker Agent 📝

Emmanuel Onwuegbusi — Fri, 25 Apr 2025 11:57:47 +0000

In this article, we will set up and run a No-code meeting note taker agent that records and transcribes meetings, generates meeting summaries from the transcription, and saves them into a knowledge base you can interact with, ask for key points, etc.

Outline

Sign up on Supercog
Start the Meeting NoteTaker Agent
Send the bot to join the Meeting
Ask for info from the meeting
Conclusion

Sign up on Supercog

Go to Supercog https://app.supercog.ai/register/ and register:

Supercog is an advanced AI platform that transforms productivity by connecting directly to your business systems and automating tasks. It enables real-time data analysis, generates insights, and empowers teams to create customizable AI solutions tailored to their needs. You can build AI Agents with Supercog to automate tasks.

Start the Meeting NoteTaker Agent

Agents are systems that use LLMs as reasoning engines to determine which actions to take and the inputs to pass to them.

On the homepage (https://app.supercog.ai/home/), scroll to Templates and click the Meeting Bot Agent tab to start chatting quickly:

Send the bot to join the Meeting

In the agent edit page, go to the chat box and enter your prompt that includes your meeting URL

Example:

Join this meeting: https://meet.google.com/example-url-here=here

The bot will join your meeting, record it until it ends, and provide the data as it goes. Supercog will generate a summary from the meeting transcript and index the summary for the RAG process so that you can ask questions to get information from the meeting and get a response based on the meeting.

Ask for info from the meeting

Once the meeting is complete or you leave the meeting, you can go to the chat box to ask questions and get info based on the meeting. For example, in my case, I am finding out what the key points discussed in the meeting were:

You can ask more questions about the meeting, and Supercog will give you responses based on the meeting data.

Conclusion

You can easily do the following and more using Supercog:

Integrate seamlessly with various business systems and popular SaaS applications
Automate repetitive tasks
Do advanced data analysis
Deep research
Podcast generation
Report generation
File data processing, etc

Build Your Own AI Meeting Notetaker Agent using Supercog Agentic Framework

Build Your Own Podcast Producer AI Agent🎙️

Emmanuel Onwuegbusi — Fri, 18 Apr 2025 17:07:09 +0000

In this article, we'll explore how to build an AI News Podcast Producer Agent that automatically generates, narrates, and publishes daily news updates covering AI, Sports, and Finance using Supercog Agentic Framework. This powerful agent combines multiple AI models and tools to create professional-quality podcast episodes.

Outline 📋

Installation Options
Set up Required API Keys
Running the Podcast Agent
Customizing the Prompts
Architecture Overview
Conclusion

Installation Options 🛠️

You have two options for installation:

Option 1: Install from PyPI (Recommended)

# Create and activate a virtual environment
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

# Install from PyPI
pip install agentic-framework

# Initialize your project
agentic init .

This will create a basic project structure and copy example agents into your directory.

Option 2: Install from Source

# Clone the repository
git clone https://github.com/supercog-ai/agentic.git

# Change to the agentic directory
cd agentic

# Install with all dependencies
uv pip install -e ".[all,dev]"

Set up required API keys 🔑

To use the Podcast Agent, you'll need to set up the following API keys:

Transistor API Key & Show ID:
- Create an account at Transistor.fm
- Create a new podcast show
- Get your Show ID from the URL: https://dashboard.transistor.fm/shows/SHOW-ID/episodes
- Get your API key from Your Account > API Access
Tavily API Key:
- Sign up at Tavily
- Navigate to your dashboard to get your API key
OpenAI API Key:
- Sign up at OpenAI
- Create an API key in your account settings
Anthropic API Key:
- Sign up at Anthropic
- Get your API key from the dashboard

You can set these keys:

Environment Variables:

export TRANSISTOR_API_KEY=your_transistor_key
export TRANSISTOR_SHOW_ID=your_show_id
export TAVILY_API_KEY=your_tavily_key
export OPENAI_API_KEY=your_openai_key
export ANTHROPIC_API_KEY=your_anthropic_key

Running the Podcast Agent 🚀

Navigate to the examples directory:

cd examples/podcast

Run the podcast agent:

python podcast_short.py

Enter the command to start podcast production:

run

The agent will then:

Generate AI news using Claude
Generate sports news using Claude
Generate finance news using Claude
Format the news for broadcast
Convert the text to speech
Publish the episode to Transistor.fm

You can listen to an example episode here: https://share.transistor.fm/s/95fa8302

Customizing the Prompts 🎯

The agent uses prompts defined in podcast_short.yaml to generate each news segment. You can customize these prompts to change:

The style and tone of reporting
The topics covered
The length and detail of each segment
The sources and focus of news gathering

Here's an example of the AI News Reporter prompt:

AI_NEWS_REPORTER: >
  You are an experienced, hard-hitting news reporter. You are preparing a news report.
  Follow these steps precisely:
  1. Search for headlines, using query_news, about "AI and artificial intelligence" but exclude "motley fool".
  2. Download pages for the most interesting articles, max 10.
  3. Now create a long, extensive "morning news" report in the style of NPR or CNN, but with a hard news edge, and reporting as "Supercog News", at least 10,000 characters. Do not print any paragraph headers.

Feel free to modify these prompts to create your own unique podcast format!

Architecture Overview 🏗️

The podcast agent uses several components:

Google News Tool for gathering news
Tavily Search Tool for additional research
Text-to-Speech Tool for narration
Claude and GPT-4 for content generation and formatting
Transistor.fm API for podcast publishing

Each news segment is generated by a specialized agent (AI, Sports, Finance) that uses both news gathering tools and language models to create professional broadcast-style content.

Conclusion 🎉

The AI News Podcast Agent demonstrates the power of the Supercog Agentic Framework for creating complex, multi-step automation workflows. By combining multiple AI models and tools, we can create a fully automated podcast production system that generates, narrates, and publishes professional-quality content.

To learn more about Supercog Agentic Framework:

Visit the GitHub repository: https://github.com/supercog-ai/agentic
Check out the documentation: https://supercog-ai.github.io/agentic/latest/
Join the Discord community: https://discord.gg/EmPGShjmGu

Don't forget to star the repository if you find it useful! ⭐

Build Your Own AI People Research Agent using Supercog Agentic Framework 🔍

Emmanuel Onwuegbusi — Thu, 17 Apr 2025 14:43:14 +0000

In this article, we'll explore how to build an AI People Research Agent that can help you gather detailed information about professionals, their career progression, and company backgrounds. This powerful agent combines LinkedIn data with intelligent analysis to create comprehensive professional profiles.

Outline

Install Supercog Agentic Framework
Set up required API keys
Start the People Researcher Agent
Run your first people research
Understanding the output
Conclusion

Install Supercog Agentic Framework 🛠️

Currently, the easiest way to run Supercog agentic framework is from source. We'll use uv for package management:

Clone the Supercog agentic repository:

git clone https://github.com/supercog-ai/agentic.git

Change to the agentic directory:

cd agentic

Install the project in editable mode with all optional and development tools using uv:

uv pip install -e ".[all,dev]"

Set up required API keys 🔑

To use the People Researcher agent, you'll need to set up the following API keys:

RapidAPI Key (for LinkedIn data access)
OpenAI API Key (for the AI model)

You can set these in one of three ways:

Environment Variables:

export RAPIDAPI_KEY=your_rapidapi_key
export OPENAI_API_KEY=your_openai_api_key

.env File:

RAPIDAPI_KEY=your_rapidapi_key
OPENAI_API_KEY=your_openai_api_key

Using agentic secrets:

agentic secrets set "RAPIDAPI_KEY=your_rapidapi_key"
agentic secrets set "OPENAI_API_KEY=your_openai_api_key"

You can get your RapidAPI key from: https://rapidapi.com/

Start the People Researcher Agent 🚀

Run the following command to start the People Researcher agent:

python examples/people_researcher.py

This will launch the agent in interactive mode, ready to accept your research requests.

Run your first people research 🔍

Once the agent is running, you can start researching people by providing their name and company. Here's an example:

Do a research on Emmanuel Onwuegbusi, he works at Supercog AI

The agent will:

Search for matching LinkedIn profiles
If multiple matches are found, it will ask you to select the correct one
Gather detailed profile information
Research the company background
Generate a comprehensive report

Understanding the output 📊

The agent will provide a detailed report that includes:

Profile overview (name, location, LinkedIn URL)
Career progression
Current role details
Company background
Education history
Skills and endorsements
Certifications and achievements

Here's a snippet example of what the output might look like:

### Background Report on Emmanuel Onwuegbusi

**Profile Overview:**
- **Name:** Emmanuel Onwuegbusi
- **Location:** Nigeria
- **LinkedIn Profile:** [Emmanuel Onwuegbusi](https://www.linkedin.com/in/emmanuelonwuegbusi)
- **Profile Picture:** ![Profile Picture](https://media.licdn.com/dms/image/v2/C5603AQG2ND_gMGxa9w/profile-displayphoto-shrink_800_800/profile-displayphoto-shrink_800_800/0/1559317269391?e=1750291200&v=beta&t=qumIdOQHknAilHHKTKlG4IVW-6kNRDU57XV7v8ETrCI)
- **Summary:** Emmanuel is a Creative Software Engineer with expertise in Software Engineering, Data Science, Machine Learning, and Technical Writing. He leverages his creative skills and technical knowledge to lead and build data-driven applications.

**Career Progression:**

1. **Current Role: Software Engineer at Supercog AI**
   - **Duration:** September 2024 - Present
   - **Location:** San Francisco, California, United States
   - **Description:** Emmanuel is involved in solving complex problems in application and data integration using GenAI and agentic architectures.
   - **Company Overview:** Supercog AI is a technology company specializing in AI and machine learning solutions, focusing on enhancing business operations through innovative AI-driven products and services.

Conclusion 🎉

The People Researcher agent is a powerful tool for gathering professional information and creating detailed background reports. It's particularly useful for:

Recruiters looking to understand candidate backgrounds
Business professionals researching potential partners or clients
Anyone needing detailed professional profiles

You can customize your research by:

Adding specific companies to narrow down searches
Requesting particular aspects of a person's background
Focusing on specific time periods in their career

To learn more about Supercog Agentic Framework:

Visit the GitHub repository: https://github.com/supercog-ai/agentic
Check out the documentation: https://supercog-ai.github.io/agentic/latest/
Join the Discord community: https://discord.gg/EmPGShjmGu

Don't forget to star the repository if you find it useful! ⭐

Build Your Own AI Meeting Notetaker Agent using Supercog Agentic Framework 🚀

Emmanuel Onwuegbusi — Fri, 04 Apr 2025 16:26:56 +0000

In this article, we will learn to build an AI Meeting Notetaker Agent that records and transcribes meetings, generates meeting summaries from the transcription, and saves that into a knowledge base you can interact with, ask for key points, etc.

Outline

Install Supercog Agentic Framework
Set the required API keys
Set up ngrok for Webhook Callbacks
Start the Meeting NoteTaker Agent
Send bot to Join Meeting
Ask for info from meeting
Conclusion

Install Supercog Agentic Framework

Currently, it's probably easiest to run Supercog agentic framework from source. We use uv for package management:

Git clone supercog agentic:

git clone https://github.com/supercog-ai/agentic.git

change directory to agentic

cd agentic

Install the project in editable mode with all optional and development tools using uv, a faster alternative to pip

uv pip install -e ".[all,dev]"

Set the required API keys

Set the following API keys to use OPENAI llm and Meetings Bots As A Service to for example, join meetings.

export OPENAI_API_KEY=your_openai_api_key
export MEETING_BAAS_API_KEY=your_meetingbaas_api_key

OR
Adding them to .env file

OPENAI_API_KEY=your_openai_api_key
MEETING_BAAS_API_KEY=your_meetingbaas_api_key

OR
using the agentic secrets set command:

agentic secrets set "OPENAI_API_KEY=your_openai_api_key"
agentic secrets set "MEETING_BAAS_API_KEY=your_meetingbaas_api_key"

You can get your meetingbaas API key from: https://meetingbaas.com/

Set up ngrok for Webhook Callbacks

The Meeting Notetaker Agent needs to receive webhook callbacks from the MeetingBaaS service. Since the agent runs locally, we need to expose it to the internet using a tunneling service like ngrok. Here's how to set it up:

Install ngrok:

# On Ubuntu/Debian
sudo apt update && sudo apt install ngrok

# On macOS
brew install ngrok

# On Windows
# Download from https://ngrok.com/download

Sign up for a free ngrok account at https://ngrok.com/ and get your authtoken
Configure ngrok with your authtoken:

ngrok config add-authtoken your_authtoken_here

Start ngrok to tunnel to your agent's port (default 8086):

ngrok http 8086

Set the DEVTUNNEL_HOST environment variable to your ngrok URL:

export DEVTUNNEL_HOST=https://your-ngrok-url.ngrok.io

OR add it to your .env file:

DEVTUNNEL_HOST=https://your-ngrok-url.ngrok.io

Now when you start the Meeting Notetaker Agent, it will be able to receive webhook callbacks from MeetingBaaS through the ngrok tunnel.

Start the Meeting NoteTaker Agent

Run the following command in the terminal to start the Next.js - based web dashboard interface on http://localhost:3000 (by default) and to
simultaneously launch the meeting notetaker agent server (FastAPI) in the background on port 8086 by default (specified by --agent-path examples/meeting_notetaker.py)

agentic dashboard start --agent-path examples/meeting_notetaker.py

Once you start the web dashboard and the FastAPI web server, you can then go to http://localhost:3000 on your web browser to access the dashboard.

Send Bot to Join Meeting

You can copy your meeting URL and paste with a prompt like the following to send the bot to join your meeting:

Join this meeting: https://meet.google.com/example-url-here=here

The bot will join your meeting, record it until it ends, and provide the data as it goes. Supercog agentic will generate a summary from the meeting transcript and index the summary for the RAG process so that you can ask questions to get information from the meeting and get a response based on the meeting.

Ask for info from meeting

You can ask more questions about the meeting, and Supercog agentic framework is going to give you responses based on the meeting data.

Conclusion

You can see more about Supercog Agentic Framework: https://github.com/supercog-ai/agentic

If you are interested in a No-code meeting Note taker agent, you can check out the Supercog Platform: https://supercog.ai/

Also, read this article for a guide: Straightforward No-code Meeting Notetaker Agent

Docs: https://supercog-ai.github.io/agentic/latest/
Join the Discord: https://discord.gg/EmPGShjmGu

How I Build AI Agents in Seconds🤯

Emmanuel Onwuegbusi — Thu, 17 Oct 2024 15:46:30 +0000

In this article, I will show you how I create AI agents that quickly perform my tasks.

As an example, I will create an AI Agent that scrapes the web for me and provides the summary of the scraped webpage.

Outline:

Sign up on Supercog
Create an Agent
Add tools
Enter query
Conclusion

Sign up on Supercog

Go to Supercog https://app.supercog.ai/register/ and register:

Create an Agent

Once you register, you will be taken to the homepage of Supercog app, from this page we can create an AI Agent.

Agents are systems that use LLMs as reasoning engines to determine which actions to take and the inputs to pass them.

Click the Create Your Own Agent button

You can give your Agent a Name and a custom Agent Instructions

Add tools

Tools extend the agent's capabilities by allowing it to perform specific actions, like accessing an external database, etc

We are going to add Zyte Web Scraping Tool to be able to scrape web pages.

Click the Add Tool button

Locate the Internet Agent Tools category, expand it and click on the "+" button to add Zyte Web Scraping Tool:

Enter query

You can now enter your query to scrape web pages. Go to the chat input box and enter your query.

For me, I entered the following text:
Scrape this webpage for me and provide a summary of the main ideas: https://dev.to/emmakodes/seamlessly-create-jira-issues-from-github-using-natural-language-and-supercog-297m_

I got the following response which is a good summary of the article I wrote explaining how to seamlessly Create Jira Issues from GitHub Using Natural Language and Supercog 👏:

Conclusion

You can easily do the following and more using Supercog:

Integrate seamlessly with various business systems and popular SaaS applications
Help to automate repetitive tasks
Do advanced data analysis
Report generation
File data processing
etc

Get News Updates automatically posted to your Discord using Supercog

Emmanuel Onwuegbusi — Fri, 04 Oct 2024 13:44:39 +0000

In this article, we will learn to get News updates on any topic automatically posted to your Discord channel using Supercog.

Supercog is an advanced AI platform that transforms productivity by connecting directly to your business systems and automating tasks. It enables real-time data analysis, generates insights, and empowers teams to create customizable AI solutions tailored to their needs.

Outline

Get your Discord Channel Webhook URL
Sign up on Supercog
Create an agent
Add Tools
Customize the Agent Instructions
Enter Query
Conclusion

You can watch the video tutorial:

Get your Discord Channel Webhook URL

First, you'll need to create a webhook for the specific channel you want to post to.

In Discord:

Go to the channel settings (Edit Channel) :

Click on "Integrations"
Create "New Webhook" or use the existing webhook
Copy the webhook URL

Sign up on Supercog

Go to Supercog https://app.supercog.ai/register/ and register:

Create an agent

Agents are systems that use LLMs as reasoning engines to determine which actions to take and the inputs to pass them.

Click the Morning News Report agent tab to start chatting quickly or Create a New Agent for the task you want to accomplish. Click on the Morning News Report agent for this article.

Add Tools

Tools extend the agent's capabilities by allowing it to perform specific actions, like accessing an external database, etc

We already have most of the tools we need to get News updates in the Morning News Report agent. We are using Tavily Web Search and Web Browsing (Scale SERP) to perform searches and get the News. Text to Speech tool to transform text into high-quality, real-time speech with minimal latency.

We are going to add Discord Tool to be able to send the News to your Discord channel.
Add Discord Tool

Click on the Add Tool button

Click the Connectors dropdown
Scroll down to the Discord tool

Click on the "+" button to add the Discord tool. You will see the New Connection: Discord modal. Enter the Discord Webhook URL you created earlier then click Save:

Customize the Agent Instructions

If you want, you can customize the agent instructions to fit your needs. In my case, I will leave it as is since I want to get news about AI.

Enter Query

You can now enter your query to get the News update on any topic and post to your Discord channel. Go to the chat input box and enter your query.

For me, I entered the following text:

and I got the following output:

I can then enter the following text in the chatbox to send the News update to my discord channel:

And I get the following output in my discord channel:

Awesome🎉

Conclusion

You can easily do the following and more using Supercog:

Integrate seamlessly with various business systems and popular SaaS applications
help to automate repetitive tasks
Do advanced data analysis
report generation
file data processing etc

Seamlessly Create Jira Issues from GitHub Using Natural Language and Supercog

Emmanuel Onwuegbusi — Sat, 28 Sep 2024 19:27:18 +0000

In this article, we will learn to create Jira issues from GitHub using Natural language and Supercog.

Outline

Get your Jira token
Get your GitHub token
Sign up on Supercog
Create an Agent or Click Supercog
Add tools
Enter query
Conclusion

You can watch the video tutorial:

Get your Jira token

Go to Your Profile and Settings tab then click on Manage account. From the nav links, click on Security then scroll and you will find API tokens section. You can then click on Create and manage API tokens to Create your Jira API token

Get your GitHub token

Go to https://github.com/settings/tokens?type=beta to generate your GitHub personal access token

Sign up on Supercog

Go to Supercog's page https://app.supercog.ai/ and sign up:

Create an Agent or Click Supercog

Click the Supercog tab to start chatting quickly or Create a New Agent for the task you want to accomplish. We will click on the Supercog tab for this article to chat quickly.

Add tools

From the right, click on the Add Tool button:

From there, click on the Connectors tab, you will see JIRA as an option. Click on the '+' button then Make connection:
Once you click on the Make connection button, you will see New Connection: JIRA modal:

Type in your:

Jira Username: which is your Jira email address
Jira Token: The token you generated
Jira Url: Your Jira Project Url. It can be something like: https://myproject.atlassian.net/

Then you click Save

Add GitHub tool: Still Click on the Connectors Tools Tab. Click on the '+' button then Make connection. You will see the following modal:

Put in your generated GitHub access token, then click Save

Enter query

We can now start chatting with our GitHub and Jira repos and projects. You can ask any question you want.

Since, we intend to create Jira issues or task from GitHub using Natural language. In the chat box, I can get details of an issue using the following prompt:

query: please show me issue #7 of emmakodes talk-to-your-data repo

and I got the following response:

and then I can easily say in the chat:

query: Now create a jira issue in the AS project from that content

AS is my Jira project_key

and I got the following output:

So Cool🎉

I can go to my Jira Project to see the issue.

Yay👏 We have created the issue in our Jira project:

Conclusion

You can easily do the following and more using Supercog:

Integrate seamlessly with various business systems and popular SaaS applications
help to automate repetitive tasks
Do advanced data analysis
report generation
file data processing etc

Chat with your Supabase Database using Natural language and Supercog

Emmanuel Onwuegbusi — Sat, 21 Sep 2024 06:06:53 +0000

This article will teach you how to interact with your Supabase database using natural language through Supercog.

Outline

Get your Supabase Database URL
Sign up on Supercog
Create an Agent or Click Supercog
Add tools
Enter query
Conclusion

Get your Supabase Database URL

Go to your supabase Project Settings -> Database -> Connection string
Copy your connection string. You will need it to connect to your supabase database.

Sign up on Supercog

Go to Supercog's page https://app.supercog.ai/ and sign up:

Create an Agent or click Supercog

Click the Supercog tab to start chatting quickly or Create a New Agent for the task you want to accomplish. We will click on the Supercog tab for this article to chat quickly.

Add tools

From the right, click on the Add Tool button:

From there, click on the Connectors tab, you will see Database as an option. Click on the '+' button then Make a connection:

Once you click on the Make connection button, you will be shown the New Connection: Database pop up:

You will need to put in the connection string you copied from supabase to The Connection URL for the database input box, then you click Save.

Add The Charting tools. Click on Dev Tools Tab, then click the '+' button to add the Charting tool. We will use this to create our plot.

Enter query

We can now start chatting with our connected supabase database. You can ask any question you want about your database.

For me, I entered the following prompt:
What were the top 3 products sold in the month of August? Make a plot of the result. Use the product_data table and sales_data table but first get their schema

since I have a product table and a sales table. I wanted to know my top 3 products sold in August and also see the plot😊 Super interesting, right?🚀:

I got the following output. It shows my top 3 products sold in the month of August and also the plot:

Conclusion

Interacting with your database is just one of those things you can do with supercog. You can also:

Automate Repetitive Tasks: Set up agents to handle routine processes on a scheduled or on-demand basis.
Connect to various business systems like HubSpot, Postgres, and Jira for seamless data flow
Do advanced Data Analysis
Generate Reports & Insights
Connect to Popular SaaS Applications: Utilize integrations with popular applications for enhanced functionality.
Process File Data: Read and process various file types to extract and utilize relevant information. etc.

Create your own Custom LLM Agent Using Open Source Models (llama3.1)

Emmanuel Onwuegbusi — Fri, 16 Aug 2024 18:30:26 +0000

In this article, we will learn how to create a custom agent that uses an open source llm (llama3.1) that runs locally on our PC. We will also use Ollama and LangChain.

Outline

Install Ollama
Pull model
Serve model
Create a new folder, open it with a code editor
Create and activate Virtual environment
Install langchain langchain-ollama
Build Custom agent with open source model in Python
Conclusion

Install Ollama

Follow the instructions based on your OS type in its GitHub README to install Ollama:

https://github.com/ollama/ollama

I am on a Linux-based PC, so I am going to run the following command in my terminal:

curl -fsSL https://ollama.com/install.sh | sh

Pull model

Fetch the available LLM model via the following command:

ollama pull llama3.1

This will download the default tagged version of the model. Typically, the default points to the latest, smallest sized-parameter model. In this case, it will be llama3.1:8b model.

To download another version of the model, you can go to: https://ollama.com/library/llama3.1 and select the version to install, and then run the ollama pull command with the model and its version number. Example: ollama pull llama3.1:70b

On Mac, the models will be downloaded to ~/.ollama/models

On Linux (or WSL), the models will be stored at /usr/share/ollama/.ollama/models

Serve model

Run the following command to start ollama without running the desktop application.

ollama serve

All models are automatically served on localhost:11434

Create a new folder, open it with a code editor

Create a new folder on your computer and then open it with a code editor like VS Code.

Create and activate Virtual environment

Open the terminal. Use the following command to create a virtual environment .venv and activate it:

python3 -m venv .venv

source .venv/bin/activate

Install langchain langchain-ollama

Run the following command to install langchain and langchain-ollama:

pip install -U langchain langchain-ollama

The above command will install or upgrade the LangChain and LangChain-Ollama packages in Python. The -U flag ensures that the latest versions of these packages are installed, replacing any older versions that may already be present.

Build Custom agent with open source model in Python

Create a Python file for example: main.py and add the following code:

from langchain_ollama import ChatOllama
from langchain.agents import tool
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.agents.format_scratchpad.openai_tools import (
    format_to_openai_tool_messages,
)
from langchain.agents import AgentExecutor
from langchain.agents.output_parsers.openai_tools import OpenAIToolsAgentOutputParser


llm = ChatOllama(
            model="llama3.1",
            temperature=0,
            verbose=True
        )

@tool
def get_word_length(word: str) -> int:
    """Returns the length of a word."""
    return len(word)


tools = [get_word_length]



prompt = ChatPromptTemplate.from_messages(
            [
                (
                    "system",
                    "You are very powerful assistant",
                ),
                ("user", "{input}"),
                MessagesPlaceholder(variable_name="agent_scratchpad"),
            ]
        )

llm_with_tools = llm.bind_tools(tools)

agent = (
    {
        "input": lambda x: x["input"],
        "agent_scratchpad": lambda x: format_to_openai_tool_messages(
            x["intermediate_steps"]
        ),
    }
    | prompt
    | llm_with_tools
    | OpenAIToolsAgentOutputParser()
)

# Create an agent executor by passing in the agent and tools
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
result = agent_executor.invoke({"input": "How many letters in the word educa"})

if result:
    print(f"[Output] --> {result['output']}")
else:
    print('There are no result..')

The above code snippet sets up a LangChain agent using the ChatOllama model (llama3.1) to process user input and utilize a custom tool that calculates word length. It defines a prompt template for the agent, binds the tool to the language model, and constructs an agent that processes input and formats intermediate steps. Finally, it creates an AgentExecutor to invoke the agent with a specific input. We pass a simple question to ask "How many letters in the word educa" and then we print the output or indicate if no result was found.

When we run, we get the following result:

> Entering new AgentExecutor chain...

Invoking: `get_word_length` with `{'word': 'educa'}`


5The word "educa" has 5 letters.

> Finished chain.
[Output] --> The word "educa" has 5 letters.

You see the agent used the model (llama3.1) to call the tool correctly to get the count of letters in the word.

Conclusion

Thanks for reading.

Check Ollama repo here: https://github.com/ollama/ollama

How to Run Llama-3.1🦙 locally in Python using Ollama, LangChain

Emmanuel Onwuegbusi — Fri, 02 Aug 2024 16:03:23 +0000

In this article, we will learn how to run Llama-3.1 model locally on our PC using Ollama and LangChain in Python

Outline

Install Ollama
Pull model
Serve model
Create a new folder, open it with a code editor
Create and activate Virtual environment
Install langchain-ollama
Run Ollama with model in Python
Conclusion

Install Ollama

Follow the instructions based on your OS type in its GitHub README to install Ollama:

https://github.com/ollama/ollama

I am on a Linux-based PC, so I am going to run the following command in my terminal:

curl -fsSL https://ollama.com/install.sh | sh

Pull model

Fetch the available LLM model via the following command:

ollama pull llama3.1

This will download the default tagged version of the model. Typically, the default points to the latest, smallest sized-parameter model. In this case, it will be llama3.1:8b model.

On Mac, the models will be downloaded to ~/.ollama/models

On Linux (or WSL), the models will be stored at /usr/share/ollama/.ollama/models

Serve model

Run the following command to start ollama without running the desktop application.

ollama serve

All models are automatically served on localhost:11434

Create a new folder, open it with a code editor

Create a new folder on your computer and then open it with a code editor like VS Code.

Create and activate Virtual environment

Open the terminal. Use the following command to create a virtual environment .venv and activate it:

python3 -m venv .venv

source .venv/bin/activate

Install langchain-ollama

Run the following command to install langchain-ollama:

pip install -U langchain-ollama

The above command will install or upgrade the LangChain Ollama package in Python. This package allows users to integrate and interact with Ollama models, which are open-source large language models, within the LangChain framework. The -U flag ensures that the package is upgraded to the latest version if it is already installed.

Run Ollama with model in Python

Create a Python file for example: main.py and add the following code:

from langchain_ollama import OllamaLLM

llm = OllamaLLM(model="llama3.1")

response = llm.invoke("The first man on the moon was ...")
print(response)

The above code imports the OllamaLLM class from the LangChain library and initializes an instance of the language model "llama3.1". We pass a prompt about the first man on the moon, and store the generated response in the variable response. When we run the above code we get the following response from the model:

...Neil Armstrong!

On July 20, 1969, Neil Armstrong became the first person to set foot on the lunar surface during the Apollo 11 mission. As he stepped off the lunar module Eagle and onto the moon's surface, he famously declared: "That's one small step for man, one giant leap for mankind."

Conclusion

Thanks for reading.
You can view the Ollama documentation for more commands.

DEV Community: Emmanuel Onwuegbusi

How to build a pitch deck triage agent with LangGraph and Nango

Why is it hard to build a pipeline like this?

Why use Nango for this

Outline

Sign up for Nango and get your secret key

Add the Gmail and Slack integrations

Connect your Gmail and Slack accounts

Scaffold the Nango integration folder

Write the list-pitch-emails action

Write the fetch-attachment action

Write the send-slack-message action

Deploy the actions to Nango

Set up the LangGraph project

Add the thesis, MCP client, PDF, and assessment files

Build the LangGraph pipeline

Write the entry point

Generate sample pitch decks

Run a Triage Run

Common issues

Conclusion

Build Your Own AI Agent that Can Browse the Web and Take Actions 🤖

Outline 📋

Installation 🛠️

Set up Required API Keys 🔑

Running the OSS Operator Agent 🚀

Customizing the Agent 🎯

Conclusion 🎉

Troubleshooting 🔧

Straightforward No-code Meeting Notetaker Agent 📝

Outline

Sign up on Supercog

Start the Meeting NoteTaker Agent

Send the bot to join the Meeting

Ask for info from the meeting

Conclusion

Build Your Own Podcast Producer AI Agent🎙️

Outline 📋

Installation Options 🛠️

Option 1: Install from PyPI (Recommended)

Option 2: Install from Source

Set up required API keys 🔑

Running the Podcast Agent 🚀

Customizing the Prompts 🎯

Architecture Overview 🏗️

Conclusion 🎉

Build Your Own AI People Research Agent using Supercog Agentic Framework 🔍

Install Supercog Agentic Framework 🛠️

Set up required API keys 🔑

Start the People Researcher Agent 🚀

Run your first people research 🔍

Understanding the output 📊

Conclusion 🎉

Build Your Own AI Meeting Notetaker Agent using Supercog Agentic Framework 🚀

Install Supercog Agentic Framework

Set the required API keys

Set up ngrok for Webhook Callbacks

Start the Meeting NoteTaker Agent

Send Bot to Join Meeting

Ask for info from meeting

Conclusion

How I Build AI Agents in Seconds🤯

Outline:

Sign up on Supercog

Create an Agent

Add tools

Enter query

Conclusion

Get News Updates automatically posted to your Discord using Supercog

Outline

Get your Discord Channel Webhook URL

Sign up on Supercog

Create an agent

Add Tools

Customize the Agent Instructions

Enter Query

Conclusion

Seamlessly Create Jira Issues from GitHub Using Natural Language and Supercog

Get your Jira token

Get your GitHub token

Write the `list-pitch-emails` action

Write the `fetch-attachment` action

Write the `send-slack-message` action