# How to integrate College football data MCP with Vercel AI SDK v6 ```json { "title": "How to integrate College football data MCP with Vercel AI SDK v6", "toolkit": "College football data", "toolkit_slug": "college_football_data", "framework": "Vercel AI SDK", "framework_slug": "ai-sdk", "url": "https://composio.dev/toolkits/college_football_data/framework/ai-sdk", "markdown_url": "https://composio.dev/toolkits/college_football_data/framework/ai-sdk.md", "updated_at": "2026-05-12T10:07:13.308Z" } ``` ## Introduction This guide walks you through connecting College football data to Vercel AI SDK v6 using the Composio tool router. By the end, you'll have a working College football data agent that can show betting lines for this week's games, get tv schedule for sec games this weekend, list advanced box scores for ohio state through natural language commands. This guide will help you understand how to give your Vercel AI SDK agent real control over a College football data account through Composio's College football data MCP server. Before we dive in, let's take a quick look at the key ideas and tools involved. ## Also integrate College football data with - [OpenAI Agents SDK](https://composio.dev/toolkits/college_football_data/framework/open-ai-agents-sdk) - [Claude Agent SDK](https://composio.dev/toolkits/college_football_data/framework/claude-agents-sdk) - [Claude Code](https://composio.dev/toolkits/college_football_data/framework/claude-code) - [Claude Cowork](https://composio.dev/toolkits/college_football_data/framework/claude-cowork) - [Codex](https://composio.dev/toolkits/college_football_data/framework/codex) - [OpenClaw](https://composio.dev/toolkits/college_football_data/framework/openclaw) - [Hermes](https://composio.dev/toolkits/college_football_data/framework/hermes-agent) - [CLI](https://composio.dev/toolkits/college_football_data/framework/cli) - [Google ADK](https://composio.dev/toolkits/college_football_data/framework/google-adk) - [LangChain](https://composio.dev/toolkits/college_football_data/framework/langchain) - [Mastra AI](https://composio.dev/toolkits/college_football_data/framework/mastra-ai) - [LlamaIndex](https://composio.dev/toolkits/college_football_data/framework/llama-index) - [CrewAI](https://composio.dev/toolkits/college_football_data/framework/crew-ai) ## TL;DR Here's what you'll learn: - How to set up and configure a Vercel AI SDK agent with College football data integration - Using Composio's Tool Router to dynamically load and access College football data tools - Creating an MCP client connection using HTTP transport - Building an interactive CLI chat interface with conversation history management - Handling tool calls and results within the Vercel AI SDK framework ## What is Vercel AI SDK? The Vercel AI SDK is a TypeScript library for building AI-powered applications. It provides tools for creating agents that can use external services and maintain conversation state. Key features include: - streamText: Core function for streaming responses with real-time tool support - MCP Client: Built-in support for Model Context Protocol via @ai-sdk/mcp - Step Counting: Control multi-step tool execution with stopWhen: stepCountIs() - OpenAI Provider: Native integration with OpenAI models ## What is the College football data MCP server, and what's possible with it? The College football data MCP server is an implementation of the Model Context Protocol that connects your AI agent and assistants like Claude, Cursor, etc directly to your College Football Data account. It provides structured and secure access to comprehensive college football stats, schedules, advanced analytics, and recruiting data, so your agent can fetch game results, analyze team performance, retrieve broadcast info, and explore historical metrics on your behalf. - Retrieve game schedules and results: Instantly fetch upcoming games, past scores, and matchup outcomes filtered by season, week, team, or conference. - Analyze advanced team and player stats: Have your agent pull in-depth box scores, advanced metrics, and season-long analytics to compare team or player performance. - Access media and broadcast information: Quickly get details on TV, radio, and streaming coverage for selected games, including broadcast schedules and platforms. - Review team talent and recruiting rankings: Let your agent track composite team talent scores and recruiting class data across seasons for any program. - Explore historical conference and division data: Effortlessly trace a team's conference membership history, division alignment, and related metadata over time. ## Supported Tools | Tool slug | Name | Description | |---|---|---| | `COLLEGE_FOOTBALL_DATA_ADVANCED_BOX_SCORE` | Advanced Box Score | Retrieves advanced analytics for a single college football game including: - Team metrics: PPA (Predicted Points Added), success rates, rushing efficiency, havoc rates, scoring opportunities - Player metrics: Usage rates by quarter and play type, individual PPA breakdowns - Game info: Teams, scores, win probabilities, excitement index Requires a valid gameId from Get Games and Results action. Returns detailed breakdown by quarter. | | `COLLEGE_FOOTBALL_DATA_ADVANCED_GAME_STATS` | Advanced Game Stats | Tool to retrieve advanced team metrics at the game level. Use when detailed offensive and defensive metrics (success rates, explosiveness, havoc) are needed. | | `COLLEGE_FOOTBALL_DATA_ADVANCED_SEASON_STATS_TEAM` | Advanced Season Stats by Team | Retrieve advanced season-level team statistics including PPA (Predicted Points Added), success rates, explosiveness, havoc metrics, and rushing/passing efficiency breakdowns. Use this for in-depth team performance analysis beyond basic stats. At least one of 'year' or 'team' must be provided. | | `COLLEGE_FOOTBALL_DATA_BETTING_LINES` | Betting Lines | Tool to fetch betting lines and totals by game and provider. Use when you need current or historical betting line data filtered by specific criteria. | | `COLLEGE_FOOTBALL_DATA_COMPOSITE_TEAM_TALENT` | Composite Team Talent | Fetches 247Sports composite team talent rankings for a given season. Returns a list of all FBS teams ranked by their composite talent score, which is based on aggregate recruit ratings. Higher scores indicate rosters with more highly-rated recruits. | | `COLLEGE_FOOTBALL_DATA_CONFERENCE_MEMBERSHIPS_HISTORY` | Conference Memberships | Tool to retrieve current conference memberships for college football teams. Returns which teams belong to which conference, optionally filtered by conference. Use to find all teams in a specific conference or to see the current conference landscape. | | `COLLEGE_FOOTBALL_DATA_DIVISIONS_BY_CONFERENCE` | Divisions by Conference | Tool to list FBS/FCS conference divisions with active years and metadata. Use after specifying an optional season year to filter active divisions. | | `COLLEGE_FOOTBALL_DATA_GET_CONFERENCE_SP` | Get Conference SP+ Ratings | Retrieve aggregated historical conference SP+ (Success Rate + Points Per Play) ratings for college football conferences. Use this to get conference-level offensive, defensive, and special teams metrics aggregated from all teams in each conference. Filter by year to get specific season data, or by conference name to get historical ratings for a specific conference. | | `COLLEGE_FOOTBALL_DATA_GET_DRIVE_DATA` | Get Drive Data | Retrieves college football drive-level data including offensive/defensive teams, yards gained, drive results (TD, PUNT, INT, etc.), time elapsed, and scoring information. Use to analyze drive efficiency, red zone performance, or game flow. Requires year; optionally filter by week, team, conference, or season type (regular/postseason). | | `COLLEGE_FOOTBALL_DATA_GET_FIELD_GOAL_EXPECTED_POINTS` | Get Field Goal Expected Points | Retrieves field goal expected points values for various field positions and distances. Returns static model data showing expected points for field goal attempts based on distance. Useful for analyzing field goal decision-making and expected value calculations. | | `COLLEGE_FOOTBALL_DATA_GET_FPI` | FPI Ratings | Retrieves historical Football Power Index (FPI) ratings for college football teams. FPI is ESPN's measure that predicts team strength and game outcomes. Use this to get team ratings, efficiency metrics, and resume rankings. Specify a year to get all teams' ratings for that season, or a team name to get historical ratings, or both for a specific team-season combination. | | `COLLEGE_FOOTBALL_DATA_GET_GAME_HAVOC_STATS` | Get Game Havoc Stats | Tool to retrieve havoc statistics aggregated by game. Use when you need game-level havoc metrics including DB havoc rate, front seven havoc rate, and total havoc events for offense and defense. | | `COLLEGE_FOOTBALL_DATA_GET_GAME_MEDIA` | Get Game Media | Retrieve broadcast information for college football games including TV channels, streaming platforms, and radio outlets. Use this to find where games are being broadcast. Returns information about the broadcaster/outlet, start time, and teams involved. Common use cases: - Find TV channel for a specific game: set year, week, and team - Get all broadcasts for a conference: set year and conference - Find streaming options: set mediaType='web' - Get bowl game broadcasts: set seasonType='postseason' | | `COLLEGE_FOOTBALL_DATA_GET_GAMES_AND_RESULTS` | Get Games and Results | Tool to retrieve college American football games and results for a given season/week/team. Use when you need game schedules or outcomes filtered by specific criteria. Covers NCAA only; NFL and other sports return no data. Overly narrow filter combinations (e.g., mismatched `team` and `conference`) may yield zero results — relax filters if the response is empty. | | `COLLEGE_FOOTBALL_DATA_GET_PLAYER_GAME_STATS` | Get Player Game Stats | Fetches detailed player statistics for college football games. Returns individual player stats (passing, rushing, receiving, defensive, kicking, etc.) organized by game and team. Use cases: - Get QB passing stats for a specific team's games - View rushing leaders for a conference in a given week - Analyze defensive stats for postseason games NOTE: Requires 'year' plus at least one of: 'week', 'team', or 'conference'. Use 'category' filter to limit results to specific stat types (recommended for faster responses). | | `COLLEGE_FOOTBALL_DATA_GET_PLAYER_USAGE` | Get Player Usage | Retrieves player usage data for a given season. Returns usage percentages across different play situations (overall, passing, rushing, by down, etc.). Use this to analyze how frequently players are involved in plays, filtered by team, conference, position, or specific player. | | `COLLEGE_FOOTBALL_DATA_GET_PLAY_TYPES` | Get Play Types | Tool to fetch all available play types. Use when you need a catalog of play types for filtering or referencing play data. | | `COLLEGE_FOOTBALL_DATA_GET_PREDICTED_POINTS_ADDED_BY_TEAM` | Get Predicted Points Added By Team | Tool to retrieve historical team Predicted Points Added (PPA) metrics by season. Use when you need season-level PPA performance data for teams to analyze offensive and defensive efficiency across play types and down situations. | | `COLLEGE_FOOTBALL_DATA_GET_PREGAME_WIN_PROBABILITIES` | Get Pregame Win Probabilities | Tool to retrieve pregame win probabilities for college football games. Use when you need predictive data about game outcomes before they are played, filtered by season, week, or team. | | `COLLEGE_FOOTBALL_DATA_GET_RECRUITS` | Get Recruits | Retrieves player recruiting rankings from the College Football Data API. Returns detailed information about high school, prep school, and junior college recruits including star ratings, composite ratings, rankings, physical measurements, and commitment status. Use this action to analyze recruiting classes by year or team, compare recruits by position or location, or track where top prospects commit. At least one of year or team parameters must be provided. | | `COLLEGE_FOOTBALL_DATA_GET_STATS_CATEGORIES` | Get Stats Categories | Tool to fetch all available team statistical categories. Use when you need to discover valid category names for statistical analysis or filtering team stats. | | `COLLEGE_FOOTBALL_DATA_GET_TEAM_GAME_STATS` | Get Team Game Stats | Fetch team-level box score statistics for college football games. Returns detailed game stats including offense (rushing/passing yards, TDs, turnovers), defense (tackles, sacks, interceptions), and special teams (kick/punt returns) for each team. Use cases: - Get box scores for a specific team's games in a season - Compare team performance across conference games in a given week - Analyze offensive/defensive stats for a specific matchup Note: At least one of week, team, or conference must be provided to filter results. | | `COLLEGE_FOOTBALL_DATA_GET_TEAM_RECRUITING_RANKINGS` | Get Team Recruiting Rankings | Retrieve team recruiting rankings from the College Football Data API. Returns composite recruiting rankings based on recruit star ratings and commitments. Use to compare recruiting success across teams or track a team's recruiting performance over time. | | `COLLEGE_FOOTBALL_DATA_GET_TEAMS_ATS` | Get Teams ATS Records | Tool to retrieve against-the-spread (ATS) summary by team. Use when you need historical betting performance data showing how teams performed relative to point spreads. | | `COLLEGE_FOOTBALL_DATA_GET_USER_INFO` | Get User Info | Retrieves information about the authenticated user from the College Football Data API. Returns the user's Patreon subscription level and remaining API calls for rate limit monitoring. Use this to check your current API quota and subscription status. | | `COLLEGE_FOOTBALL_DATA_GET_WIN_PROBABILITY` | Get Win Probability | Tool to query play-by-play win probabilities for a specific game. Use when you need detailed probability metrics showing how win likelihood changed throughout the game. | | `COLLEGE_FOOTBALL_DATA_LIST_COACHES_AND_HISTORY` | List Coaches and History | Tool to get coaching records and history. Use when you need coaches’ season-by-season data with optional filters. | | `COLLEGE_FOOTBALL_DATA_LIST_CONFERENCES` | List Conferences | Retrieves all college football conferences from the College Football Data API. Returns conferences across all NCAA divisions (FBS, FCS, Division II, Division III). Use this to get conference IDs for filtering other API calls or to display conference information. No parameters required - returns the complete list of conferences. | | `COLLEGE_FOOTBALL_DATA_LIST_FBS_TEAMS` | List FBS Teams | Tool to list FBS teams for a given season. Use after selecting the season year to retrieve all FBS teams. | | `COLLEGE_FOOTBALL_DATA_LIST_FCS_TEAMS` | List FCS Teams | Tool to list FCS teams for a given season and conference. Use when you need a list of FCS programs filtered by season year and conference. | | `COLLEGE_FOOTBALL_DATA_LIST_TEAMS` | List Teams | Retrieve a list of college football teams from the CFBD (College Football Data) API. Use this action to: - Get all college football teams (call with no parameters) - Get teams from a specific season (use year parameter) - Get teams from a specific conference (use conference parameter) - Combine filters to get conference teams for a specific season Returns team details including: name, mascot, abbreviation, conference, classification (FBS/FCS/D2/D3), team colors, logos, Twitter handle, and stadium/venue information. | | `COLLEGE_FOOTBALL_DATA_LIST_VENUES_STADIUMS` | List Venues and Stadiums | Tool to list college football venues with metadata (name, capacity, location, etc.). Use when you need detailed venue information for a specific season. | | `COLLEGE_FOOTBALL_DATA_NFL_DRAFT_PICKS` | NFL Draft Picks | Tool to list NFL Draft picks. Use when you need draft pick data by year, round, team, player, etc. | | `COLLEGE_FOOTBALL_DATA_NFL_DRAFT_POSITIONS` | NFL Draft Positions | Retrieves the standardized list of NFL draft positions. Returns all position names and abbreviations used to classify players in NFL drafts. Useful for filtering draft picks by position or understanding position categories in draft analysis. No parameters required. | | `COLLEGE_FOOTBALL_DATA_NFL_DRAFT_TEAMS` | NFL Draft Teams | Tool to list NFL teams used in draft endpoints. Use when preparing to retrieve NFL draft data by team. | | `COLLEGE_FOOTBALL_DATA_PLAY_BY_PLAY_DATA` | Play-by-Play Data | Tool to fetch play-by-play data for college football games. Use when you need detailed play logs filtered by season, week, team, or game. | | `COLLEGE_FOOTBALL_DATA_PLAY_STATS_PLAYER` | Play Stats Player | Fetch player-level statistics tied to individual plays. Returns detailed stats for each player's contribution to a play (rushes, receptions, completions, etc.). Use this when you need: - Play-by-play player statistics - Granular data on individual player performance per play - Analysis of a specific athlete's game contributions Note: Recommend filtering by year/week/team or gameId to limit result size. | | `COLLEGE_FOOTBALL_DATA_PLAY_STAT_TYPES` | Play Stat Types | Tool to fetch all play-level stat type definitions. Use when you need a catalog of available play stat types for filtering or referencing. | | `COLLEGE_FOOTBALL_DATA_PPA_PLAYER_BY_GAME_ACTION` | Player PPA by Game | Retrieve player-level PPA (Predicted Points Added) / EPA (Expected Points Added) stats for individual games. PPA measures how many points a player adds/subtracts compared to average performance on similar plays. Use this tool to analyze individual player contributions per game, filtered by season, week, team, or position. IMPORTANT: Either 'week' OR 'team' must be specified in the request. | | `COLLEGE_FOOTBALL_DATA_PPA_PLAYER_BY_SEASON` | PPA Player By Season | Tool to fetch player-level PPA/EPA aggregated by season. Use when you need seasonal PPA metrics for specific players or groups after applying filters. | | `COLLEGE_FOOTBALL_DATA_PPA_PREDICTED_POINTS_EP` | Predict Expected Points (EP) | Get expected points (EP) for all field positions given a specific down and distance scenario. Returns expected points values for yard lines 1-99, useful for analyzing game situations and fourth-down decisions. Common scenarios: 1st and 10, 3rd and short, 4th and goal. | | `COLLEGE_FOOTBALL_DATA_PPA_TEAM_BY_GAME` | PPA Team By Game | Tool to retrieve team Predicted Points Added (PPA) by game. Use when you need team-level PPA metrics for games after filtering by season, week, team, or date. | | `COLLEGE_FOOTBALL_DATA_RANKINGS_POLLS` | Rankings Polls | Retrieve college football poll rankings (AP Top 25, Coaches Poll, Playoff Committee, FCS, Division II/III). Returns weekly rankings including team rank, school name, conference, first-place votes, and points. Use this tool to look up historical or current poll standings for any season from 1900 to present. Required: year (e.g., 2023). Optional: season_type (regular/postseason), week number. | | `COLLEGE_FOOTBALL_DATA_RATINGS_ELO` | Elo Ratings | Tool to retrieve Elo ratings for college football teams. Use when you need historical Elo ratings by season or for a specific team. | | `COLLEGE_FOOTBALL_DATA_RATINGS_SP_PLUS` | SP+ Ratings | Retrieve SP+ (Success Rate + Points Per Play) team ratings for college football. SP+ is an advanced tempo- and opponent-adjusted measure of college football efficiency. Use this to get overall team ratings, offensive/defensive rankings, and special teams metrics. Specify a year to get all teams' ratings for that season, or a team name to get historical ratings across seasons, or both for a specific team-season combination. | | `COLLEGE_FOOTBALL_DATA_RATINGS_SRS` | SRS Ratings | Retrieves Simple Rating System (SRS) team ratings. SRS measures team strength based on point differential adjusted for strength of schedule. Either year or team parameter must be provided. Use year to get all teams' ratings for a season, or team to get historical ratings for a specific team. | | `COLLEGE_FOOTBALL_DATA_RECRUITING_GROUP_DICTIONARY` | Recruiting Group Dictionary | Retrieves aggregated college football recruiting data grouped by position. Use this tool to analyze recruiting performance by position group for specific teams or conferences. Returns composite ratings, star averages, and commit counts by position group (e.g., Quarterback, Receiver, Defensive Back). Useful for comparing recruiting strength across different positions or evaluating team/conference recruiting patterns. | | `COLLEGE_FOOTBALL_DATA_RECRUITING_TRANSFER_PORTAL` | Recruiting Transfer Portal | Retrieves NCAA college football transfer portal entries for a given season. Returns player transfer information including origin school, destination school (if committed), position, star rating, transfer rating, transfer date, and eligibility status. Useful for tracking player movement between schools, analyzing transfer trends, and identifying key transfers. Data is available from 2021 onwards when the transfer portal became widely used. | | `COLLEGE_FOOTBALL_DATA_RETURNING_PRODUCTION_TEAM` | Returning Production by Team | Tool to fetch Bill Connelly–style returning production splits by team and season. Use when evaluating returning offense, defense, and overall production for teams in a given season. | | `COLLEGE_FOOTBALL_DATA_SEARCH_PLAYERS` | Search Players | Search for college football players by name. Returns top 100 results matching the search term. Use this action to find players by name and optionally filter by year, team, or position. | | `COLLEGE_FOOTBALL_DATA_SEASON_STATS_PLAYER` | Season Stats Player | Fetch aggregated season statistics for college football players. Returns individual player stats by category (passing, rushing, receiving, defensive, kicking, etc.) for a specified year. Useful for comparing player performance across a season or filtering by team/conference. | | `COLLEGE_FOOTBALL_DATA_SEASON_STATS_TEAM` | Season Team Stats | Tool to get basic season stats aggregated by team and season. Use when you need a summary of team-level statistics for a particular season. | | `COLLEGE_FOOTBALL_DATA_SEASON_TYPES_DICTIONARY` | Season Types Dictionary | Retrieve the list of available season types for a specific college football year. Returns types like 'regular', 'postseason', and for certain years 'spring_regular', 'spring_postseason'. Use this to discover valid seasonType values to pass to other endpoints. | | `COLLEGE_FOOTBALL_DATA_TEAM_MATCHUP_HISTORY` | Team Matchup History | Tool to retrieve head-to-head team matchup records over a date range. Use after selecting two FBS teams to compare their matchup history. | | `COLLEGE_FOOTBALL_DATA_TEAM_RECORDS` | Get team season records | Retrieve college football team win-loss records for a specific season. Returns detailed breakdowns including total, conference, home, away, neutral site, regular season, and postseason records. Requires a year parameter. Optionally filter by team name, conference, division, or season type. | | `COLLEGE_FOOTBALL_DATA_TEAM_ROSTER` | Get Team Roster | Fetches the roster for a college football team for a specific season. Returns player details including name, position, height, weight, jersey number, academic year, and hometown info. Use this to get player information for any FBS or FCS team from 2009 onwards. | ## Supported Triggers None listed. ## Creating MCP Server - Stand-alone vs Composio SDK The College football data MCP server is an implementation of the Model Context Protocol that connects your AI agent to College football data. It provides structured and secure access so your agent can perform College football data operations on your behalf through a secure, permission-based interface. With Composio's managed implementation, you don't have to create your own developer app. For production, if you're building an end product, we recommend using your own credentials. The managed server helps you prototype fast and go from 0-1 faster. ## Step-by-step Guide ### 1. Prerequisites Before you begin, make sure you have: - Node.js and npm installed - A Composio account with API key - An OpenAI API key ### 1. Getting API Keys for OpenAI and Composio OpenAI API Key - Go to the [OpenAI dashboard](https://platform.openai.com/settings/organization/api-keys) and create an API key. You'll need credits to use the models, or you can connect to another model provider. - Keep the API key safe. Composio API Key - Log in to the [Composio dashboard](https://dashboard.composio.dev?utm_source=toolkits&utm_medium=framework_docs). - Navigate to your API settings and generate a new API key. - Store this key securely as you'll need it for authentication. ### 2. Install required dependencies First, install the necessary packages for your project. What you're installing: - @ai-sdk/openai: Vercel AI SDK's OpenAI provider - @ai-sdk/mcp: MCP client for Vercel AI SDK - @composio/core: Composio SDK for tool integration - ai: Core Vercel AI SDK - dotenv: Environment variable management ```bash npm install @ai-sdk/openai @ai-sdk/mcp @composio/core ai dotenv ``` ### 3. Set up environment variables Create a .env file in your project root. What's needed: - OPENAI_API_KEY: Your OpenAI API key for GPT model access - COMPOSIO_API_KEY: Your Composio API key for tool access - COMPOSIO_USER_ID: A unique identifier for the user session ```bash OPENAI_API_KEY=your_openai_api_key_here COMPOSIO_API_KEY=your_composio_api_key_here COMPOSIO_USER_ID=your_user_id_here ``` ### 4. Import required modules and validate environment What's happening: - We're importing all necessary libraries including Vercel AI SDK's OpenAI provider and Composio - The dotenv/config import automatically loads environment variables - The MCP client import enables connection to Composio's tool server ```typescript import "dotenv/config"; import { openai } from "@ai-sdk/openai"; import { Composio } from "@composio/core"; import * as readline from "readline"; import { streamText, type ModelMessage, stepCountIs } from "ai"; import { createMCPClient } from "@ai-sdk/mcp"; const composioAPIKey = process.env.COMPOSIO_API_KEY; const composioUserID = process.env.COMPOSIO_USER_ID; if (!process.env.OPENAI_API_KEY) throw new Error("OPENAI_API_KEY is not set"); if (!composioAPIKey) throw new Error("COMPOSIO_API_KEY is not set"); if (!composioUserID) throw new Error("COMPOSIO_USER_ID is not set"); const composio = new Composio({ apiKey: composioAPIKey, }); ``` ### 5. Create Tool Router session and initialize MCP client What's happening: - We're creating a Tool Router session that gives your agent access to College football data tools - The create method takes the user ID and specifies which toolkits should be available - The returned mcp object contains the URL and authentication headers needed to connect to the MCP server - This session provides access to all College football data-related tools through the MCP protocol ```typescript async function main() { // Create a tool router session for the user const session = await composio.create(composioUserID!, { toolkits: ["college_football_data"], }); const mcpUrl = session.mcp.url; ``` ### 6. Connect to MCP server and retrieve tools What's happening: - We're creating an MCP client that connects to our Composio Tool Router session via HTTP - The mcp.url provides the endpoint, and mcp.headers contains authentication credentials - The type: "http" is important - Composio requires HTTP transport - tools() retrieves all available College football data tools that the agent can use ```typescript const mcpClient = await createMCPClient({ transport: { type: "http", url: mcpUrl, headers: session.mcp.headers, // Authentication headers for the Composio MCP server }, }); const tools = await mcpClient.tools(); ``` ### 7. Initialize conversation and CLI interface What's happening: - We initialize an empty messages array to maintain conversation history - A readline interface is created to accept user input from the command line - Instructions are displayed to guide the user on how to interact with the agent ```typescript let messages: ModelMessage[] = []; console.log("Chat started! Type 'exit' or 'quit' to end the conversation.\n"); console.log( "Ask any questions related to college_football_data, like summarize my last 5 emails, send an email, etc... :)))\n", ); const rl = readline.createInterface({ input: process.stdin, output: process.stdout, prompt: "> ", }); rl.prompt(); ``` ### 8. Handle user input and stream responses with real-time tool feedback What's happening: - We use streamText instead of generateText to stream responses in real-time - toolChoice: "auto" allows the model to decide when to use College football data tools - stopWhen: stepCountIs(10) allows up to 10 steps for complex multi-tool operations - onStepFinish callback displays which tools are being used in real-time - We iterate through the text stream to create a typewriter effect as the agent responds - The complete response is added to conversation history to maintain context - Errors are caught and displayed with helpful retry suggestions ```typescript rl.on("line", async (userInput: string) => { const trimmedInput = userInput.trim(); if (["exit", "quit", "bye"].includes(trimmedInput.toLowerCase())) { console.log("\nGoodbye!"); rl.close(); process.exit(0); } if (!trimmedInput) { rl.prompt(); return; } messages.push({ role: "user", content: trimmedInput }); console.log("\nAgent is thinking...\n"); try { const stream = streamText({ model: openai("gpt-5"), messages, tools, toolChoice: "auto", stopWhen: stepCountIs(10), onStepFinish: (step) => { for (const toolCall of step.toolCalls) { console.log(`[Using tool: ${toolCall.toolName}]`); } if (step.toolCalls.length > 0) { console.log(""); // Add space after tool calls } }, }); for await (const chunk of stream.textStream) { process.stdout.write(chunk); } console.log("\n\n---\n"); // Get final result for message history const response = await stream.response; if (response?.messages?.length) { messages.push(...response.messages); } } catch (error) { console.error("\nAn error occurred while talking to the agent:"); console.error(error); console.log( "\nYou can try again or restart the app if it keeps happening.\n", ); } finally { rl.prompt(); } }); rl.on("close", async () => { await mcpClient.close(); console.log("\n👋 Session ended."); process.exit(0); }); } main().catch((err) => { console.error("Fatal error:", err); process.exit(1); }); ``` ## Complete Code ```typescript import "dotenv/config"; import { openai } from "@ai-sdk/openai"; import { Composio } from "@composio/core"; import * as readline from "readline"; import { streamText, type ModelMessage, stepCountIs } from "ai"; import { createMCPClient } from "@ai-sdk/mcp"; const composioAPIKey = process.env.COMPOSIO_API_KEY; const composioUserID = process.env.COMPOSIO_USER_ID; if (!process.env.OPENAI_API_KEY) throw new Error("OPENAI_API_KEY is not set"); if (!composioAPIKey) throw new Error("COMPOSIO_API_KEY is not set"); if (!composioUserID) throw new Error("COMPOSIO_USER_ID is not set"); const composio = new Composio({ apiKey: composioAPIKey, }); async function main() { // Create a tool router session for the user const session = await composio.create(composioUserID!, { toolkits: ["college_football_data"], }); const mcpUrl = session.mcp.url; const mcpClient = await createMCPClient({ transport: { type: "http", url: mcpUrl, headers: session.mcp.headers, // Authentication headers for the Composio MCP server }, }); const tools = await mcpClient.tools(); let messages: ModelMessage[] = []; console.log("Chat started! Type 'exit' or 'quit' to end the conversation.\n"); console.log( "Ask any questions related to college_football_data, like summarize my last 5 emails, send an email, etc... :)))\n", ); const rl = readline.createInterface({ input: process.stdin, output: process.stdout, prompt: "> ", }); rl.prompt(); rl.on("line", async (userInput: string) => { const trimmedInput = userInput.trim(); if (["exit", "quit", "bye"].includes(trimmedInput.toLowerCase())) { console.log("\nGoodbye!"); rl.close(); process.exit(0); } if (!trimmedInput) { rl.prompt(); return; } messages.push({ role: "user", content: trimmedInput }); console.log("\nAgent is thinking...\n"); try { const stream = streamText({ model: openai("gpt-5"), messages, tools, toolChoice: "auto", stopWhen: stepCountIs(10), onStepFinish: (step) => { for (const toolCall of step.toolCalls) { console.log(`[Using tool: ${toolCall.toolName}]`); } if (step.toolCalls.length > 0) { console.log(""); // Add space after tool calls } }, }); for await (const chunk of stream.textStream) { process.stdout.write(chunk); } console.log("\n\n---\n"); // Get final result for message history const response = await stream.response; if (response?.messages?.length) { messages.push(...response.messages); } } catch (error) { console.error("\nAn error occurred while talking to the agent:"); console.error(error); console.log( "\nYou can try again or restart the app if it keeps happening.\n", ); } finally { rl.prompt(); } }); rl.on("close", async () => { await mcpClient.close(); console.log("\n👋 Session ended."); process.exit(0); }); } main().catch((err) => { console.error("Fatal error:", err); process.exit(1); }); ``` ## Conclusion You've successfully built a College football data agent using the Vercel AI SDK with streaming capabilities! This implementation provides a powerful foundation for building AI applications with natural language interfaces and real-time feedback. Key features of this implementation: - Real-time streaming responses for a better user experience with typewriter effect - Live tool execution feedback showing which tools are being used as the agent works - Dynamic tool loading through Composio's Tool Router with secure authentication - Multi-step tool execution with configurable step limits (up to 10 steps) - Comprehensive error handling for robust agent execution - Conversation history maintenance for context-aware responses You can extend this further by adding custom error handling, implementing specific business logic, or integrating additional Composio toolkits to create multi-app workflows. ## How to build College football data MCP Agent with another framework - [OpenAI Agents SDK](https://composio.dev/toolkits/college_football_data/framework/open-ai-agents-sdk) - [Claude Agent SDK](https://composio.dev/toolkits/college_football_data/framework/claude-agents-sdk) - [Claude Code](https://composio.dev/toolkits/college_football_data/framework/claude-code) - [Claude Cowork](https://composio.dev/toolkits/college_football_data/framework/claude-cowork) - [Codex](https://composio.dev/toolkits/college_football_data/framework/codex) - [OpenClaw](https://composio.dev/toolkits/college_football_data/framework/openclaw) - [Hermes](https://composio.dev/toolkits/college_football_data/framework/hermes-agent) - [CLI](https://composio.dev/toolkits/college_football_data/framework/cli) - [Google ADK](https://composio.dev/toolkits/college_football_data/framework/google-adk) - [LangChain](https://composio.dev/toolkits/college_football_data/framework/langchain) - [Mastra AI](https://composio.dev/toolkits/college_football_data/framework/mastra-ai) - [LlamaIndex](https://composio.dev/toolkits/college_football_data/framework/llama-index) - [CrewAI](https://composio.dev/toolkits/college_football_data/framework/crew-ai) ## Related Toolkits - [Excel](https://composio.dev/toolkits/excel) - Microsoft Excel is a robust spreadsheet application for organizing, analyzing, and visualizing data. It's the go-to tool for calculations, reporting, and flexible data management. - [21risk](https://composio.dev/toolkits/_21risk) - 21RISK is a web app built for easy checklist, audit, and compliance management. It streamlines risk processes so teams can focus on what matters. - [Abstract](https://composio.dev/toolkits/abstract) - Abstract provides a suite of APIs for automating data validation and enrichment tasks. It helps developers streamline workflows and ensure data quality with minimal effort. - [Addressfinder](https://composio.dev/toolkits/addressfinder) - Addressfinder is a data quality platform for verifying addresses, emails, and phone numbers. It helps you ensure accurate customer and contact data every time. - [Agentql](https://composio.dev/toolkits/agentql) - Agentql is a toolkit that connects AI agents to the web using a specialized query language. It enables structured web interaction and data extraction for smarter automations. - [Agenty](https://composio.dev/toolkits/agenty) - Agenty is a web scraping and automation platform for extracting data and automating browser tasks—no coding needed. It streamlines data collection, monitoring, and repetitive online actions. - [Ambee](https://composio.dev/toolkits/ambee) - Ambee is an environmental data platform providing real-time, hyperlocal APIs for air quality, weather, and pollen. Get precise environmental insights to power smarter decisions in your apps and workflows. - [Ambient weather](https://composio.dev/toolkits/ambient_weather) - Ambient Weather is a platform for personal weather stations with a robust API for accessing local, real-time, and historical weather data. Get detailed environmental insights directly from your own sensors for smarter apps and automations. - [Anonyflow](https://composio.dev/toolkits/anonyflow) - Anonyflow is a service for encryption-based data anonymization and secure data sharing. It helps organizations meet GDPR, CCPA, and HIPAA data privacy compliance requirements. - [Api ninjas](https://composio.dev/toolkits/api_ninjas) - Api ninjas offers 120+ public APIs spanning categories like weather, finance, sports, and more. Developers use it to supercharge apps with real-time data and actionable endpoints. - [Api sports](https://composio.dev/toolkits/api_sports) - Api sports is a comprehensive sports data platform covering 2,000+ competitions with live scores and 15+ years of stats. Instantly access up-to-date sports information for analysis, apps, or chatbots. - [Apify](https://composio.dev/toolkits/apify) - Apify is a cloud platform for building, deploying, and managing web scraping and automation tools called Actors. It lets you automate data extraction and workflow tasks at scale—no infrastructure headaches. - [Autom](https://composio.dev/toolkits/autom) - Autom is a lightning-fast search engine results data platform for Google, Bing, and Brave. Developers use it to access fresh, low-latency SERP data on demand. - [Beaconchain](https://composio.dev/toolkits/beaconchain) - Beaconchain is a real-time analytics platform for Ethereum 2.0's Beacon Chain. It provides detailed insights into validators, blocks, and overall network performance. - [Big data cloud](https://composio.dev/toolkits/big_data_cloud) - BigDataCloud provides APIs for geolocation, reverse geocoding, and address validation. Instantly access reliable location intelligence to enhance your applications and workflows. - [Bigpicture io](https://composio.dev/toolkits/bigpicture_io) - BigPicture.io offers APIs for accessing detailed company and profile data. Instantly enrich your applications with up-to-date insights on 20M+ businesses. - [Bitquery](https://composio.dev/toolkits/bitquery) - Bitquery is a blockchain data platform offering indexed, real-time, and historical data from 40+ blockchains via GraphQL APIs. Get unified, reliable access to complex on-chain data for analytics, trading, and research. - [Brightdata](https://composio.dev/toolkits/brightdata) - Brightdata is a leading web data platform offering advanced scraping, SERP APIs, and anti-bot tools. It lets you collect public web data at scale, bypassing blocks and friction. - [Builtwith](https://composio.dev/toolkits/builtwith) - BuiltWith is a web technology profiler that uncovers the technologies powering any website. Gain actionable insights into analytics, hosting, and content management stacks for smarter research and lead generation. - [Byteforms](https://composio.dev/toolkits/byteforms) - Byteforms is an all-in-one platform for creating forms, managing submissions, and integrating data. It streamlines workflows by centralizing form data collection and automation. ## Frequently Asked Questions ### What are the differences in Tool Router MCP and College football data MCP? With a standalone College football data MCP server, the agents and LLMs can only access a fixed set of College football data tools tied to that server. However, with the Composio Tool Router, agents can dynamically load tools from College football data and many other apps based on the task at hand, all through a single MCP endpoint. ### Can I use Tool Router MCP with Vercel AI SDK v6? Yes, you can. Vercel AI SDK v6 fully supports MCP integration. You get structured tool calling, message history handling, and model orchestration while Tool Router takes care of discovering and serving the right College football data tools. ### Can I manage the permissions and scopes for College football data while using Tool Router? Yes, absolutely. You can configure which College football data scopes and actions are allowed when connecting your account to Composio. You can also bring your own OAuth credentials or API configuration so you keep full control over what the agent can do. ### How safe is my data with Composio Tool Router? All sensitive data such as tokens, keys, and configuration is fully encrypted at rest and in transit. Composio is SOC 2 Type 2 compliant and follows strict security practices so your College football data data and credentials are handled as safely as possible. --- [See all toolkits](https://composio.dev/toolkits) · [Composio docs](https://docs.composio.dev/llms.txt)