​
Overview

In this guide, we’ll build a coding agent that can help with tasks like reading files, running commands, and making code modifications. We’ll use Agenite’s powerful tools and streaming capabilities to create an interactive experience.

View the full example at GitHub.

The following diagrams illustrate the architecture and interaction flow of our coding agent:

This flow chart shows the high-level architecture of our coding agent. The agent receives user input and delegates tasks to specialized tools - the file system tool for file operations and the command runner for executing system commands.

This sequence diagram illustrates the interaction flow between components. It shows how the agent processes user requests, coordinates with the LLM for decision-making, executes tools as needed, and streams responses back to the user.

​
Required tools

Our coding agent needs two main tools:

​
Installation

npm install @agenite/agent @agenite/tool @agenite/bedrock @agenite/ollama

​
Creating the tools

Let’s implement our tools with proper error handling and type safety:

import { Tool } from '@agenite/tool';
import * as fs from 'fs/promises';
import * as path from 'path';

export function createFileSystemTool() {
  return new Tool({
    name: 'file-system',
    description: 'Perform file system operations',
    inputSchema: {
      type: 'object',
      properties: {
        operation: {
          type: 'string',
          enum: ['read', 'write', 'list', 'exists', 'mkdir'],
        },
        path: { type: 'string' },
        content: { type: 'string' },
      },
      required: ['operation', 'path'],
    },
    execute: async ({ input }) => {
      const startTime = Date.now();
      const fullPath = path.resolve(input.path);

      try {
        switch (input.operation) {
          case 'read': {
            const content = await fs.readFile(fullPath, 'utf-8');
            return {
              isError: false,
              data: content,
              duration: Date.now() - startTime,
            };
          }
          case 'write': {
            await fs.mkdir(path.dirname(fullPath), { recursive: true });
            await fs.writeFile(fullPath, input.content || '');
            return {
              isError: false,
              data: `File written to ${input.path}`,
              duration: Date.now() - startTime,
            };
          }
          // ... other operations
        }
      } catch (error) {
        return {
          isError: true,
          data: error.message,
          duration: Date.now() - startTime,
        };
      }
    },
  });
}

​
Building the agent

Now let’s create our coding agent. You can use different providers based on your needs:

import { Agent } from '@agenite/agent';
import { BedrockProvider } from '@agenite/bedrock';
import { createFileSystemTool } from './tools/file-system';
import { createCommandRunnerTool } from './tools/command-runner';

// Configure AWS Bedrock provider
const provider = new BedrockProvider({
  region: 'us-west-2',
  model: 'anthropic.claude-3-sonnet-20240229-v1:0',
});

const agent = new Agent({
  name: 'CodingAgent',
  description: 'An AI agent specialized in coding tasks',
  provider,
  instructions: 'You are an expert coding assistant. Help users with reading files, running commands, and making code modifications.',
  tools: [createFileSystemTool(), createCommandRunnerTool()],
});

For AWS Bedrock, ensure you have AWS credentials configured. For Ollama, make sure you have it installed and running locally.

​
Using the agent

Let’s see how to use our coding agent in streaming and execute modes:

import { userTextMessage } from '@agenite/agent';

// Interactive streaming mode
const iterator = agent.iterate({
  messages: [userTextMessage('Analyze the code in src/App.tsx')],
});

// Process the stream
for await (const chunk of iterator) {
  switch (chunk.type) {
    case 'agenite.llm-call.streaming':
      if (chunk.content.type === 'text') {
        process.stdout.write(chunk.content.text);
      } else if (chunk.content.type === 'toolUse') {
        console.log('Using tool:', chunk.content.toolUse);
      }
      break;
    case 'agenite.tool-result':
      console.log('Tool result:', chunk.result);
      break;
  }
}

​
Conclusion

In this guide, we built a powerful coding agent that can:

  • Read and analyze code files
  • Execute system commands safely
  • Make code modifications
  • Provide real-time feedback through streaming

The agent’s modular architecture and type-safe tools make it easy to extend and customize for your specific needs. Check out the full example on GitHub to explore more features and capabilities.