deepset-ai--haystack/docs-website/reference_versioned_docs/version-2.26/integrations-api/github.md

title, id, description, slug

title	id	description	slug
GitHub	integrations-github	GitHub integration for Haystack	/integrations-github

haystack_integrations.components.connectors.github.file_editor

Command

Bases: str, Enum

Available commands for file operations in GitHub.

Attributes: EDIT: Edit an existing file by replacing content UNDO: Revert the last commit if made by the same user CREATE: Create a new file DELETE: Delete an existing file

GitHubFileEditor

A Haystack component for editing files in GitHub repositories.

Supports editing, undoing changes, deleting files, and creating new files through the GitHub API.

Usage example

from haystack_integrations.components.connectors.github import Command, GitHubFileEditor
from haystack.utils import Secret

# Initialize with default repo and branch
editor = GitHubFileEditor(
    github_token=Secret.from_env_var("GITHUB_TOKEN"),
    repo="owner/repo",
    branch="main"
)

# Edit a file using default repo and branch
result = editor.run(
    command=Command.EDIT,
    payload={
        "path": "path/to/file.py",
        "original": "def old_function():",
        "replacement": "def new_function():",
        "message": "Renamed function for clarity"
    }
)

# Edit a file in a different repo/branch
result = editor.run(
    command=Command.EDIT,
    repo="other-owner/other-repo",  # Override default repo
    branch="feature",  # Override default branch
    payload={
        "path": "path/to/file.py",
        "original": "def old_function():",
        "replacement": "def new_function():",
        "message": "Renamed function for clarity"
    }
)

init

__init__(
    *,
    github_token: Secret = Secret.from_env_var("GITHUB_TOKEN"),
    repo: str | None = None,
    branch: str = "main",
    raise_on_failure: bool = True
) -> None

Initialize the component.

Parameters:

• github_token (Secret) – GitHub personal access token for API authentication
• repo (str | None) – Default repository in owner/repo format
• branch (str) – Default branch to work with
• raise_on_failure (bool) – If True, raises exceptions on API errors

Raises:

• TypeError – If github_token is not a Secret

run

run(
    command: Command | str,
    payload: dict[str, Any],
    repo: str | None = None,
    branch: str | None = None,
) -> dict[str, str]

Process GitHub file operations.

Parameters:

• command (Command | str) – Operation to perform ("edit", "undo", "create", "delete")
• payload (dict[str, Any]) – Dictionary containing command-specific parameters
• repo (str | None) – Repository in owner/repo format (overrides default if provided)
• branch (str | None) – Branch to perform operations on (overrides default if provided)

Returns:

• dict[str, str] – Dictionary containing operation result

Raises:

• ValueError – If command is not a valid Command enum value

to_dict

to_dict() -> dict[str, Any]

Serialize the component to a dictionary.

from_dict

from_dict(data: dict[str, Any]) -> GitHubFileEditor

Deserialize the component from a dictionary.

haystack_integrations.components.connectors.github.issue_commenter

GitHubIssueCommenter

Posts comments to GitHub issues.

The component takes a GitHub issue URL and comment text, then posts the comment to the specified issue using the GitHub API.

Usage example

from haystack_integrations.components.connectors.github import GitHubIssueCommenter
from haystack.utils import Secret

commenter = GitHubIssueCommenter(github_token=Secret.from_env_var("GITHUB_TOKEN"))
result = commenter.run(
    url="https://github.com/owner/repo/issues/123",
    comment="Thanks for reporting this issue! We'll look into it."
)

print(result["success"])

init

__init__(
    *,
    github_token: Secret = Secret.from_env_var("GITHUB_TOKEN"),
    raise_on_failure: bool = True,
    retry_attempts: int = 2
) -> None

Initialize the component.

Parameters:

• github_token (Secret) – GitHub personal access token for API authentication as a Secret
• raise_on_failure (bool) – If True, raises exceptions on API errors
• retry_attempts (int) – Number of retry attempts for failed requests

to_dict

to_dict() -> dict[str, Any]

Serialize the component to a dictionary.

Returns:

• dict[str, Any] – Dictionary with serialized data.

from_dict

from_dict(data: dict[str, Any]) -> GitHubIssueCommenter

Deserialize the component from a dictionary.

Parameters:

• data (dict[str, Any]) – Dictionary to deserialize from.

Returns:

• GitHubIssueCommenter – Deserialized component.

run

run(url: str, comment: str) -> dict

Post a comment to a GitHub issue.

Parameters:

• url (str) – GitHub issue URL
• comment (str) – Comment text to post

Returns:

• dict – Dictionary containing success status

haystack_integrations.components.connectors.github.issue_viewer

GitHubIssueViewer

Fetches and parses GitHub issues into Haystack documents.

The component takes a GitHub issue URL and returns a list of documents where:

• First document contains the main issue content
• Subsequent documents contain the issue comments

Usage example

from haystack_integrations.components.connectors.github import GitHubIssueViewer

viewer = GitHubIssueViewer()
docs = viewer.run(
    url="https://github.com/owner/repo/issues/123"
)["documents"]

print(docs)

init

__init__(
    *,
    github_token: Secret | None = None,
    raise_on_failure: bool = True,
    retry_attempts: int = 2
) -> None

Initialize the component.

Parameters:

• github_token (Secret | None) – GitHub personal access token for API authentication as a Secret
• raise_on_failure (bool) – If True, raises exceptions on API errors
• retry_attempts (int) – Number of retry attempts for failed requests

to_dict

to_dict() -> dict[str, Any]

Serialize the component to a dictionary.

Returns:

• dict[str, Any] – Dictionary with serialized data.

from_dict

from_dict(data: dict[str, Any]) -> GitHubIssueViewer

Deserialize the component from a dictionary.

Parameters:

• data (dict[str, Any]) – Dictionary to deserialize from.

Returns:

• GitHubIssueViewer – Deserialized component.

run

run(url: str) -> dict

Process a GitHub issue URL and return documents.

Parameters:

• url (str) – GitHub issue URL

Returns:

• dict – Dictionary containing list of documents

haystack_integrations.components.connectors.github.pr_creator

GitHubPRCreator

A Haystack component for creating pull requests from a fork back to the original repository.

Uses the authenticated user's fork to create the PR and links it to an existing issue.

Usage example

from haystack_integrations.components.connectors.github import GitHubPRCreator
from haystack.utils import Secret

pr_creator = GitHubPRCreator(
    github_token=Secret.from_env_var("GITHUB_TOKEN")  # Token from the fork owner
)

# Create a PR from your fork
result = pr_creator.run(
    issue_url="https://github.com/owner/repo/issues/123",
    title="Fix issue #123",
    body="This PR addresses issue #123",
    branch="feature-branch",     # The branch in your fork with the changes
    base="main"                  # The branch in the original repo to merge into
)

init

__init__(
    *,
    github_token: Secret = Secret.from_env_var("GITHUB_TOKEN"),
    raise_on_failure: bool = True
) -> None

Initialize the component.

Parameters:

• github_token (Secret) – GitHub personal access token for authentication (from the fork owner)
• raise_on_failure (bool) – If True, raises exceptions on API errors

run

run(
    issue_url: str,
    title: str,
    branch: str,
    base: str,
    body: str = "",
    draft: bool = False,
) -> dict[str, str]

Create a new pull request from your fork to the original repository, linked to the specified issue.

Parameters:

• issue_url (str) – URL of the GitHub issue to link the PR to
• title (str) – Title of the pull request
• branch (str) – Name of the branch in your fork where changes are implemented
• base (str) – Name of the branch in the original repo you want to merge into
• body (str) – Additional content for the pull request description
• draft (bool) – Whether to create a draft pull request

Returns:

• dict[str, str] – Dictionary containing operation result

to_dict

to_dict() -> dict[str, Any]

Serialize the component to a dictionary.

from_dict

from_dict(data: dict[str, Any]) -> GitHubPRCreator

Deserialize the component from a dictionary.

haystack_integrations.components.connectors.github.repo_forker

GitHubRepoForker

Forks a GitHub repository from an issue URL.

The component takes a GitHub issue URL, extracts the repository information, creates or syncs a fork of that repository, and optionally creates an issue-specific branch.

Usage example

from haystack_integrations.components.connectors.github import GitHubRepoForker
from haystack.utils import Secret

# Using direct token with auto-sync and branch creation
forker = GitHubRepoForker(
    github_token=Secret.from_env_var("GITHUB_TOKEN"),
    auto_sync=True,
    create_branch=True
)

result = forker.run(url="https://github.com/owner/repo/issues/123")
print(result)
# Will create or sync fork and create branch "fix-123"

init

__init__(
    *,
    github_token: Secret = Secret.from_env_var("GITHUB_TOKEN"),
    raise_on_failure: bool = True,
    wait_for_completion: bool = False,
    max_wait_seconds: int = 300,
    poll_interval: int = 2,
    auto_sync: bool = True,
    create_branch: bool = True
) -> None

Initialize the component.

Parameters:

• github_token (Secret) – GitHub personal access token for API authentication
• raise_on_failure (bool) – If True, raises exceptions on API errors
• wait_for_completion (bool) – If True, waits until fork is fully created
• max_wait_seconds (int) – Maximum time to wait for fork completion in seconds
• poll_interval (int) – Time between status checks in seconds
• auto_sync (bool) – If True, syncs fork with original repository if it already exists
• create_branch (bool) – If True, creates a fix branch based on the issue number

to_dict

to_dict() -> dict[str, Any]

Serialize the component to a dictionary.

Returns:

• dict[str, Any] – Dictionary with serialized data.

from_dict

from_dict(data: dict[str, Any]) -> GitHubRepoForker

Deserialize the component from a dictionary.

Parameters:

• data (dict[str, Any]) – Dictionary to deserialize from.

Returns:

• GitHubRepoForker – Deserialized component.

run

run(url: str) -> dict

Process a GitHub issue URL and create or sync a fork of the repository.

Parameters:

• url (str) – GitHub issue URL

Returns:

• dict – Dictionary containing repository path in owner/repo format

haystack_integrations.components.connectors.github.repo_viewer

GitHubItem

Represents an item (file or directory) in a GitHub repository

GitHubRepoViewer

Navigates and fetches content from GitHub repositories.

For directories:

• Returns a list of Documents, one for each item
• Each Document's content is the item name
• Full path and metadata in Document.meta

For files:

• Returns a single Document
• Document's content is the file content
• Full path and metadata in Document.meta

For errors:

• Returns a single Document
• Document's content is the error message
• Document's meta contains type="error"

Usage example

from haystack_integrations.components.connectors.github import GitHubRepoViewer

viewer = GitHubRepoViewer()

# List directory contents - returns multiple documents
result = viewer.run(
    repo="owner/repository",
    path="docs/",
    branch="main"
)
print(result)

# Get specific file - returns single document
result = viewer.run(
    repo="owner/repository",
    path="README.md",
    branch="main"
)
print(result)

init

__init__(
    *,
    github_token: Secret | None = None,
    raise_on_failure: bool = True,
    max_file_size: int = 1000000,
    repo: str | None = None,
    branch: str = "main"
) -> None

Initialize the component.

Parameters:

• github_token (Secret | None) – GitHub personal access token for API authentication
• raise_on_failure (bool) – If True, raises exceptions on API errors
• max_file_size (int) – Maximum file size in bytes to fetch (default: 1MB)
• repo (str | None) – Repository in format "owner/repo"
• branch (str) – Git reference (branch, tag, commit) to use

to_dict

to_dict() -> dict[str, Any]

Serialize the component to a dictionary.

Returns:

• dict[str, Any] – Dictionary with serialized data.

from_dict

from_dict(data: dict[str, Any]) -> GitHubRepoViewer

Deserialize the component from a dictionary.

Parameters:

• data (dict[str, Any]) – Dictionary to deserialize from.

Returns:

• GitHubRepoViewer – Deserialized component.

run

run(
    path: str, repo: str | None = None, branch: str | None = None
) -> dict[str, list[Document]]

Process a GitHub repository path and return documents.

Parameters:

• repo (str | None) – Repository in format "owner/repo"
• path (str) – Path within repository (default: root)
• branch (str | None) – Git reference (branch, tag, commit) to use

Returns:

• dict[str, list[Document]] – Dictionary containing list of documents