Github

This connector is optimized for AI agents. For the data replication connector, see Github.

The Github agent connector is a Python package that equips AI agents to interact with Github through strongly typed, well-documented tools. It's ready to use directly in your Python app, in an agent framework, or exposed through an MCP.

GitHub is a platform for version control and collaborative software development using Git. This connector provides access to repositories, branches, commits, issues, pull requests, reviews, comments, releases, discussions, organizations, teams, and users for development workflow analysis and project management insights.

Example prompts

The Github connector is optimized to handle prompts like these.

Show me all open issues in my repositories this month
List the top 5 repositories I've starred recently
Analyze the commit trends in my main project over the last quarter
Find all pull requests created in the past two weeks
Search for repositories related to machine learning in my organizations
Compare the number of contributors across my different team projects
Identify the most active branches in my main repository
Get details about the most recent releases in my organization
List all milestones for our current development sprint
Show me insights about pull request review patterns in our team
List all unanswered discussions in a repository
Show me recent discussions in the General category
Create a new issue titled 'Fix login bug' in my repository
Create an issue with labels 'bug' and 'urgent' in owner/repo
File a new bug report issue in our project repository
Create an issue and assign it to a team member
Open a new feature request issue in the repository
Close issue #42 in owner/repo as completed
Reopen issue #15 in our repository
Add the 'bug' and 'urgent' labels to issue #10
Assign user @johndoe to issue #25 in owner/repo
Update the title of issue #30 to 'New title'
Add a comment to issue #5 saying 'This has been fixed in the latest release'
Post a comment on pull request #100 with a status update
Create a pull request from feature-branch to main in owner/repo
Open a draft PR titled 'Add new feature' from my-branch to main

Unsupported prompts

The Github connector isn't currently able to handle prompts like these.

Delete an old branch from the repository
Schedule a team review for this code
Merge a pull request
Delete an issue or comment

Entities and actions

This connector supports the following entities and actions. For more details, see this connector's full reference documentation.

Entity	Actions
Repositories	Get, List, API Search, Context Store Search
Org Repositories	List, Context Store Search
Branches	List, Get, Context Store Search
Commits	List, Get, Context Store Search
Releases	List, Get, Context Store Search
Issues	List, Get, API Search, Create, Update, Context Store Search
Comments	Create, List, Get, Context Store Search
Pull Requests	Create, List, Get, API Search, Context Store Search
Reviews	List, Context Store Search
Pr Comments	List, Get, Context Store Search
Labels	List, Get, Context Store Search
Milestones	List, Get, Context Store Search
Organizations	Get, List, Context Store Search
Users	Get, List, API Search, Context Store Search
Teams	List, Get, Context Store Search
Tags	List, Get, Context Store Search
Stargazers	List, Context Store Search
Viewer	Get, Context Store Search
Viewer Repositories	List, Context Store Search
Projects	List, Get, Context Store Search
Project Items	List, Context Store Search
Discussions	List, Get, API Search, Context Store Search
File Content	Get, Context Store Search
Directory Content	List, Context Store Search

Github API docs

See the official Github API reference.

SDK installation

uv pip install airbyte-agent-sdk

SDK usage

Connectors can run in hosted or open source mode.

Hosted

In hosted mode, API credentials are stored securely in Airbyte Agents. You provide your Airbyte credentials instead. If your Airbyte client can access multiple organizations, also set organization_id.

This example assumes you've already authenticated your connector with Airbyte. See Authentication to learn more about authenticating. If you need a step-by-step guide, see the hosted execution tutorial.

The connect() factory returns a fully typed GithubConnector and reads AIRBYTE_CLIENT_ID / AIRBYTE_CLIENT_SECRET from the environment:

Pydantic AI
LangChain
OpenAI Agents
FastMCP

Pydantic AI
from pydantic_ai import Agent
from airbyte_agent_sdk import connect
from airbyte_agent_sdk.connectors.github import GithubConnector

connector = connect("github", workspace_name="<your_workspace_name>")

agent = Agent("openai:gpt-4o")

@agent.tool_plain
@GithubConnector.tool_utils
async def github_execute(entity: str, action: str, params: dict | None = None):
    return await connector.execute(entity, action, params or {})

LangChain
from langchain_core.tools import tool
from airbyte_agent_sdk import connect
from airbyte_agent_sdk.connectors.github import GithubConnector

connector = connect("github", workspace_name="<your_workspace_name>")

@tool
@GithubConnector.tool_utils
async def github_execute(entity: str, action: str, params: dict | None = None):
    """Execute Github connector operations."""
    result = await connector.execute(entity, action, params or {})
    # connector.execute returns a Pydantic envelope for typed actions; fall back to raw data otherwise.
    return result.model_dump(mode="json") if hasattr(result, "model_dump") else result

OpenAI Agents
from agents import Agent, function_tool
from airbyte_agent_sdk import connect
from airbyte_agent_sdk.connectors.github import GithubConnector

connector = connect("github", workspace_name="<your_workspace_name>")

# strict_mode=False because `params: dict` is permissive and the default strict
# JSON schema rejects objects with additionalProperties.
@function_tool(strict_mode=False)
@GithubConnector.tool_utils(framework="openai_agents")
async def github_execute(entity: str, action: str, params: dict | None = None):
    """Execute Github connector operations."""
    result = await connector.execute(entity, action, params or {})
    return result.model_dump(mode="json") if hasattr(result, "model_dump") else result

agent = Agent(name="Github Assistant", tools=[github_execute])

FastMCP
from fastmcp import FastMCP
from airbyte_agent_sdk import connect
from airbyte_agent_sdk.connectors.github import GithubConnector

connector = connect("github", workspace_name="<your_workspace_name>")

mcp = FastMCP("Github Agent")

@mcp.tool
@GithubConnector.tool_utils
async def github_execute(entity: str, action: str, params: dict | None = None):
    """Execute Github connector operations."""
    result = await connector.execute(entity, action, params or {})
    return result.model_dump(mode="json") if hasattr(result, "model_dump") else result

Or pass credentials explicitly (equivalent, useful when you're not loading them from the environment):

Pydantic AI
LangChain
OpenAI Agents
FastMCP

Pydantic AI
from pydantic_ai import Agent
from airbyte_agent_sdk.connectors.github import GithubConnector
from airbyte_agent_sdk.types import AirbyteAuthConfig

connector = GithubConnector(
    auth_config=AirbyteAuthConfig(
        workspace_name="<your_workspace_name>",
        organization_id="<your_organization_id>",  # Optional for multi-org clients
        airbyte_client_id="<your-client-id>",
        airbyte_client_secret="<your-client-secret>"
    )
)

agent = Agent("openai:gpt-4o")

@agent.tool_plain
@GithubConnector.tool_utils
async def github_execute(entity: str, action: str, params: dict | None = None):
    return await connector.execute(entity, action, params or {})

LangChain
from langchain_core.tools import tool
from airbyte_agent_sdk.connectors.github import GithubConnector
from airbyte_agent_sdk.types import AirbyteAuthConfig

connector = GithubConnector(
    auth_config=AirbyteAuthConfig(
        workspace_name="<your_workspace_name>",
        organization_id="<your_organization_id>",  # Optional for multi-org clients
        airbyte_client_id="<your-client-id>",
        airbyte_client_secret="<your-client-secret>"
    )
)

@tool
@GithubConnector.tool_utils
async def github_execute(entity: str, action: str, params: dict | None = None):
    """Execute Github connector operations."""
    result = await connector.execute(entity, action, params or {})
    # connector.execute returns a Pydantic envelope for typed actions; fall back to raw data otherwise.
    return result.model_dump(mode="json") if hasattr(result, "model_dump") else result

OpenAI Agents
from agents import Agent, function_tool
from airbyte_agent_sdk.connectors.github import GithubConnector
from airbyte_agent_sdk.types import AirbyteAuthConfig

connector = GithubConnector(
    auth_config=AirbyteAuthConfig(
        workspace_name="<your_workspace_name>",
        organization_id="<your_organization_id>",  # Optional for multi-org clients
        airbyte_client_id="<your-client-id>",
        airbyte_client_secret="<your-client-secret>"
    )
)

# strict_mode=False because `params: dict` is permissive and the default strict
# JSON schema rejects objects with additionalProperties.
@function_tool(strict_mode=False)
@GithubConnector.tool_utils(framework="openai_agents")
async def github_execute(entity: str, action: str, params: dict | None = None):
    """Execute Github connector operations."""
    result = await connector.execute(entity, action, params or {})
    return result.model_dump(mode="json") if hasattr(result, "model_dump") else result

agent = Agent(name="Github Assistant", tools=[github_execute])

FastMCP
from fastmcp import FastMCP
from airbyte_agent_sdk.connectors.github import GithubConnector
from airbyte_agent_sdk.types import AirbyteAuthConfig

connector = GithubConnector(
    auth_config=AirbyteAuthConfig(
        workspace_name="<your_workspace_name>",
        organization_id="<your_organization_id>",  # Optional for multi-org clients
        airbyte_client_id="<your-client-id>",
        airbyte_client_secret="<your-client-secret>"
    )
)

mcp = FastMCP("Github Agent")

@mcp.tool
@GithubConnector.tool_utils
async def github_execute(entity: str, action: str, params: dict | None = None):
    """Execute Github connector operations."""
    result = await connector.execute(entity, action, params or {})
    return result.model_dump(mode="json") if hasattr(result, "model_dump") else result

Open source

In open source mode, you provide API credentials directly to the connector.

Pydantic AI
LangChain
OpenAI Agents
FastMCP

Pydantic AI
from pydantic_ai import Agent
from airbyte_agent_sdk.connectors.github import GithubConnector
from airbyte_agent_sdk.connectors.github.models import GithubPersonalAccessTokenAuthConfig

connector = GithubConnector(
    auth_config=GithubPersonalAccessTokenAuthConfig(
        token="<GitHub personal access token (fine-grained or classic)>"
    )
)

agent = Agent("openai:gpt-4o")

@agent.tool_plain
@GithubConnector.tool_utils
async def github_execute(entity: str, action: str, params: dict | None = None):
    return await connector.execute(entity, action, params or {})

LangChain
from langchain_core.tools import tool
from airbyte_agent_sdk.connectors.github import GithubConnector
from airbyte_agent_sdk.connectors.github.models import GithubPersonalAccessTokenAuthConfig

connector = GithubConnector(
    auth_config=GithubPersonalAccessTokenAuthConfig(
        token="<GitHub personal access token (fine-grained or classic)>"
    )
)

@tool
@GithubConnector.tool_utils
async def github_execute(entity: str, action: str, params: dict | None = None):
    """Execute Github connector operations."""
    result = await connector.execute(entity, action, params or {})
    # connector.execute returns a Pydantic envelope for typed actions; fall back to raw data otherwise.
    return result.model_dump(mode="json") if hasattr(result, "model_dump") else result

OpenAI Agents
from agents import Agent, function_tool
from airbyte_agent_sdk.connectors.github import GithubConnector
from airbyte_agent_sdk.connectors.github.models import GithubPersonalAccessTokenAuthConfig

connector = GithubConnector(
    auth_config=GithubPersonalAccessTokenAuthConfig(
        token="<GitHub personal access token (fine-grained or classic)>"
    )
)

# strict_mode=False because `params: dict` is permissive and the default strict
# JSON schema rejects objects with additionalProperties.
@function_tool(strict_mode=False)
@GithubConnector.tool_utils(framework="openai_agents")
async def github_execute(entity: str, action: str, params: dict | None = None):
    """Execute Github connector operations."""
    result = await connector.execute(entity, action, params or {})
    return result.model_dump(mode="json") if hasattr(result, "model_dump") else result

agent = Agent(name="Github Assistant", tools=[github_execute])

FastMCP
from fastmcp import FastMCP
from airbyte_agent_sdk.connectors.github import GithubConnector
from airbyte_agent_sdk.connectors.github.models import GithubPersonalAccessTokenAuthConfig

connector = GithubConnector(
    auth_config=GithubPersonalAccessTokenAuthConfig(
        token="<GitHub personal access token (fine-grained or classic)>"
    )
)

mcp = FastMCP("Github Agent")

@mcp.tool
@GithubConnector.tool_utils
async def github_execute(entity: str, action: str, params: dict | None = None):
    """Execute Github connector operations."""
    result = await connector.execute(entity, action, params or {})
    return result.model_dump(mode="json") if hasattr(result, "model_dump") else result

Authentication

For all authentication options, see the connector's authentication documentation.

Version information

Connector version: 0.1.19

Example prompts​

Unsupported prompts​

Entities and actions​

Github API docs​

SDK installation​

SDK usage​

Hosted​

Open source​

Authentication​

Version information​