How to Integrate AI Agents with GitHub

export GITHUB_TOKEN="github_pat_your_token_here"
export GITHUB_REPO_OWNER="your-org"
export GITHUB_REPO_NAME="your-repo"

pip install langchain langchain-openai PyGithub python-dotenv

import os
from github import Github
from langchain.tools import tool
from dotenv import load_dotenv

load_dotenv()
gh = Github(os.getenv("GITHUB_TOKEN"))
repo = gh.get_repo(f"{os.getenv('GITHUB_REPO_OWNER')}/{os.getenv('GITHUB_REPO_NAME')}")


@tool
def get_pull_request(pr_number: int) -> str:
    """Get details about a specific pull request including title, description, and changed files."""
    pr = repo.get_pull(pr_number)
    files = [f.filename for f in pr.get_files()]
    return f"""PR #{pr_number}: {pr.title}
Author: {pr.user.login}
State: {pr.state}
Description: {pr.body or 'No description provided'}
Changed files: {', '.join(files[:20])}
{'...' if len(files) > 20 else ''}"""


@tool
def post_pr_comment(pr_number: int, comment: str) -> str:
    """Post a review comment on a pull request."""
    pr = repo.get_pull(pr_number)
    pr.create_issue_comment(comment)
    return f"Comment posted on PR #{pr_number}"


@tool
def get_pr_diff(pr_number: int) -> str:
    """Get the diff (code changes) for a pull request. Returns first 4000 chars."""
    pr = repo.get_pull(pr_number)
    files = pr.get_files()
    diff_text = []
    for f in files:
        diff_text.append(f"File: {f.filename}\n{f.patch or 'Binary file'}")
    return "\n---\n".join(diff_text)[:4000]


@tool
def create_issue(title: str, body: str, labels: list = None) -> str:
    """Create a new GitHub issue with optional labels."""
    issue = repo.create_issue(
        title=title,
        body=body,
        labels=labels or []
    )
    return f"Issue #{issue.number} created: {issue.html_url}"


@tool
def list_open_issues(label: str = None) -> str:
    """List open issues in the repository, optionally filtered by label."""
    issues = repo.get_issues(state='open', labels=[label] if label else [])
    result = []
    for issue in list(issues)[:20]:
        result.append(f"#{issue.number}: {issue.title} (Labels: {[l.name for l in issue.labels]})")
    return "\n".join(result) or "No open issues found"


@tool
def add_issue_labels(issue_number: int, labels: list) -> str:
    """Add labels to a GitHub issue."""
    issue = repo.get_issue(issue_number)
    issue.add_to_labels(*labels)
    return f"Labels {labels} added to issue #{issue_number}"

from langchain_openai import ChatOpenAI
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain_core.prompts import ChatPromptTemplate

llm = ChatOpenAI(model="gpt-4o", temperature=0)
tools = [get_pull_request, get_pr_diff, post_pr_comment,
         create_issue, list_open_issues, add_issue_labels]

prompt = ChatPromptTemplate.from_messages([
    ("system", """You are a senior software engineer conducting code reviews on GitHub.

When reviewing a PR:
1. Get the PR details and diff
2. Analyze for: bugs, security issues, performance problems, missing tests, style violations
3. Post a constructive, specific comment highlighting concerns and suggestions
4. Be encouraging — acknowledge good patterns alongside issues
5. Keep comments concise and actionable

When triaging issues:
1. Read the issue carefully
2. Classify: bug, enhancement, documentation, or question
3. Assess priority based on impact and urgency
4. Add appropriate labels
5. Post a helpful response"""),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}"),
])

agent = create_tool_calling_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True, max_iterations=8)

# Review a specific PR
result = executor.invoke({"input": "Review PR #47 and post a constructive code review comment"})
print(result["output"])

from datetime import datetime, timedelta

def run_issue_triage_agent():
    """Triage all issues opened in the last 24 hours."""
    cutoff = datetime.now() - timedelta(hours=24)

    # Get recent issues without labels (untriaged)
    recent_issues = repo.get_issues(state='open', since=cutoff)
    untriaged = [i for i in recent_issues if not i.labels]

    for issue in untriaged[:10]:  # Process up to 10 per run
        result = executor.invoke({
            "input": f"""Triage this GitHub issue:
Title: {issue.title}
Body: {issue.body or 'No description'}
Issue number: {issue.number}

1. Add appropriate labels (bug/enhancement/documentation/question/duplicate)
2. Post a helpful response acknowledging the issue and asking for clarification if needed
3. If it looks like a duplicate, mention that in your comment"""
        })
        print(f"Triaged #{issue.number}: {result['output']}")

# Run on schedule via cron or GitHub Actions
run_issue_triage_agent()

# .github/workflows/ai-pr-review.yml
name: AI PR Review

on:
  pull_request:
    types: [opened, synchronize]

jobs:
  review:
    runs-on: ubuntu-latest
    permissions:
      pull-requests: write
      contents: read

    steps:
      - uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.11'

      - name: Install dependencies
        run: pip install openai PyGithub

      - name: Run AI Review
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
          PR_NUMBER: ${{ github.event.pull_request.number }}
        run: python scripts/ai_pr_review.py