Building Code Agents

This guide demonstrates how to build an intelligent code agent that can analyze and manipulate codebases.

from codegen import CodeAgent, Codebase

# Grab a repo from Github
codebase = Codebase.from_repo('fastapi/fastapi')

# Create a code agent with read/write codebase access
agent = CodeAgent(codebase)

# Run the agent with a prompt
agent.run("Tell me about this repo")

The agent has access to powerful code viewing and manipulation tools powered by Codegen, including:

• ViewFileTool: View contents and metadata of files
• SemanticEditTool: Make intelligent edits to files
• RevealSymbolTool: Analyze symbol dependencies and usages
• MoveSymbolTool: Move symbols between files with import handling
• ReplacementEditTool: Make regex-based replacement editing on files
• ListDirectoryTool: List directory contents
• SearchTool: Search for files and symbols
• CreateFileTool: Create new files
• DeleteFileTool: Delete files
• RenameFileTool: Rename files
• EditFileTool: Edit files

View the full code for the default tools and agent implementation in our examples repository

Basic Usage

The following example shows how to create and run a CodeAgent:

from codegen import CodeAgent, Codebase

# Grab a repo from Github
codebase = Codebase.from_repo('fastapi/fastapi')

# Create a code agent with read/write codebase access
agent = CodeAgent(codebase)

# Run the agent with a prompt
agent.run("Tell me about this repo")

Your ANTHROPIC_API_KEY must be set in your env.

The default implementation uses anthropic/claude-3-5-sonnet-latest for the model but this can be changed through the model_provider and model_name arguments.

agent = CodeAgent(
    codebase=codebase,
    model_provider="openai",
    model_name="gpt-4o",
)

If using a non-default model provider, make sure to set the appropriate API key (e.g., OPENAI_API_KEY for OpenAI models) in your env.

Available Tools

The agent comes with a comprehensive set of tools for code analysis and manipulation. Here are some key tools:

from codegen.extensions.langchain.tools import (
    CreateFileTool,
    DeleteFileTool,
    EditFileTool,
    ListDirectoryTool,
    MoveSymbolTool,
    RenameFileTool,
    ReplacementEditTool,
    RevealSymbolTool,
    SearchTool,
    SemanticEditTool,
    ViewFileTool,
)

View the full set of tools on Github

Each tool provides specific capabilities:

Extensions

GitHub Integration

The agent includes tools for GitHub operations like PR management. Set up GitHub access with:

CODEGEN_SECRETS__GITHUB_TOKEN="..."

Import the GitHub tools:

from codegen.extensions.langchain.tools import (
    GithubCreatePRTool,
    GithubViewPRTool,
    GithubCreatePRCommentTool,
    GithubCreatePRReviewCommentTool
)

These tools enable:

• Creating pull requests
• Viewing PR contents and diffs
• Adding general PR comments
• Adding inline review comments

View all Github tools on Github

Linear Integration

The agent can interact with Linear for issue tracking and project management. To use Linear tools, set the following environment variables:

LINEAR_ACCESS_TOKEN="..."
LINEAR_TEAM_ID="..."
LINEAR_SIGNING_SECRET="..."

Import and use the Linear tools:

from codegen.extensions.langchain.tools import (
    LinearGetIssueTool,
    LinearGetIssueCommentsTool,
    LinearCommentOnIssueTool,
    LinearSearchIssuesTool,
    LinearCreateIssueTool,
    LinearGetTeamsTool
)

These tools allow the agent to:

• Create and search issues
• Get issue details and comments
• Add comments to issues
• View team information

View all Linear tools on Github

Adding Custom Tools

You can extend the agent with custom tools:

from langchain.tools import BaseTool
from pydantic import BaseModel, Field
from codegen import CodeAgent

class CustomToolInput(BaseModel):
    """Input schema for custom tool."""
    param: str = Field(..., description="Parameter description")

class CustomCodeTool(BaseTool):
    """A custom tool for the code agent."""
    name = "custom_tool"
    description = "Description of what the tool does"
    args_schema = CustomToolInput

    def _run(self, param: str) -> str:
        # Tool implementation
        return f"Processed {param}"

# Add custom tool to agent
tools.append(CustomCodeTool())
agent = CodebaseAgent(codebase, tools=tools, model_name="claude-3-5-sonnet-latest")