Creating my first agent using Mastra

Rishi — Mon, 03 Nov 2025 15:12:44 +0000

Building a Spiritual AI Agent with Mastra and Telex.im

In this blog post, I'll walk you through how I built a Bhagavad Gita AI agent using Mastra and integrated it with Telex.im - an AI agent platform similar to Zapier, but specifically designed as a Slack alternative for educational communities and bootcamps. Telex.im provides a powerful environment for deploying and managing AI agents while fostering community engagement and learning.

You can interact with my Gita Agent here: Gita Agent on Telex.im - it serves as your spiritual guide by providing verses and wisdom from the Bhagavad Gita, helping users explore ancient wisdom through modern AI technology.

The Vision & Implementation with Mastra

The idea was simple yet profound: create an AI agent that could make the timeless wisdom of the Bhagavad Gita accessible through modern technology. Users can request specific verses, get random daily inspiration, or ask for guidance on particular topics.

Key Mastra Features Utilized

Tool System: Leveraged Mastra's tool architecture to create a custom Gita verse retrieval system
Memory Management: Used Mastra's LibSQLStore for persistent conversation context
Agent Framework: Utilized the built-in agent architecture for handling complex conversations
A2A Protocol Integration: Implemented Mastra's agent-to-agent communication protocol
Observability: Enabled Mastra's default observability for monitoring and debugging
API Route Management: Used Mastra's route registration system for handling HTTP endpoints
Type Safety: Leveraged Mastra's TypeScript integration for robust type checking

Leveraging Mastra's Features

Mastra's comprehensive feature set made it the perfect choice for this project. Here's how I utilized its key capabilities:

Intelligent Agent System
- Used Mastra's agent architecture for natural language understanding
- Implemented custom instructions for Gita-specific knowledge
- Leveraged the Google Gemini model integration
Advanced Tool System
- Created custom tools with Mastra's createTool utility
- Implemented input/output schema validation using Zod
- Utilized tool error handling and retry mechanisms
Robust Memory Management
- Implemented conversation persistence with LibSQLStore
- Maintained context across user interactions
- Enabled efficient conversation history retrieval
API Integration Features
- Used built-in JSON-RPC 2.0 support
- Implemented A2A protocol handlers
- Leveraged automatic OpenAPI documentation
Development Features
- Hot reload during development
- Built-in TypeScript support
- Automatic code bundling

Implementation Journey

1. Setting Up the Agent with Mastra

The core agent setup was straightforward with Mastra:

export const gitaAgent = new Agent({
  name: 'Gita Agent',
  instructions: `
    - You are a profound and knowledgeable assistant...
  `,
  model: 'google/gemini-2.0-flash',
  tools: { gitaTool },
  memory: new Memory({
    storage: new LibSQLStore({
      url: 'file:../mastra.db',
    }),
  }),
});

2. Creating the Gita Tool

The most challenging part was implementing the verse retrieval tool. I needed to:

Handle both specific and random verse requests
Integrate with RapidAPI's Bhagavad Gita service
Manage verse boundaries for each chapter
Format responses consistently

3. A2A Protocol Integration

Telex.im integration required implementing the A2A protocol:

JSON-RPC 2.0 compliance
Proper message formatting
Error handling
Response validation

4. Challenges Faced

Verse Randomization: Implementing proper randomization while respecting chapter verse limits.
Error Handling: Gracefully handling API failures and invalid requests.
Memory Management: Setting up persistent storage for conversation context.
Response Formatting: Ensuring consistent output structure.

5. Key Learnings

Mastra's tool system is incredibly flexible
A2A protocol provides a solid foundation for agent communication
TypeScript's type system helps catch errors early
Proper error handling is crucial for production systems

Results and Impact

The agent successfully:

Handles various types of verse requests
Maintains conversation context
Provides meaningful spiritual guidance
Scales well under load

Code Structure

src/
  mastra/
    agents/
      gita-agent.ts    # Core agent definition
    tools/
      gita-tool.ts     # Verse retrieval implementation
    routes/
      a2a-agent-route.ts  # Telex.im integration

Future Improvements

Add verse commentary support
Implement verse categorization by topic
Add multi-language support
Enhance conversation memory
Include verse audio recitations

Conclusion

Building this agent demonstrated the power of combining modern AI tools with ancient wisdom. Mastra made it possible to focus on the unique aspects of the agent while handling the infrastructure complexities.

The full source code is available on GitHub, and you can try the agent on Telex.im. I'd love to hear your feedback and suggestions for improvements!

Mastra #AI #BhagavadGita #TelexIM #TypeScript

🐱 I Built a Profile API That Returns Random Cat Facts

Rishi — Sat, 18 Oct 2025 06:58:59 +0000

What I Built

As part of a backend project challenge, I created a RESTful API endpoint /me that returns:

My profile details
A dynamic cat fact
The current UTC timestamp

It uses Node.js and Express, and fetches data from the Cat Facts API

Tech Stack

Node.js
Express.js
Axios
dotenv
Railway (for deployment)

API Endpoint
GET /me

Example response:

{
  "status": "success",
  "user": {
    "email": "kumarrishi9862@gmail.com",
    "name": "Kumar Rishi",
    "stack": "Node.js/Express"
  },
  "timestamp": "2025-10-18T12:34:56.789Z",
  "fact": "Cats have over 20 muscles that control their ears."
}

Live Demo

Visit the live endpoint here:

Live Link

Endpoint:

Expected Response:

How It Works

/me endpoint returns a new response on each request
Fetches a fresh cat fact using Axios from the external API
Adds the current UTC time using new Date().toISOString()
Handles failure of the Cat Facts API gracefully

Error Handling

If the Cat Fact API fails or times out, the endpoint returns a fallback message instead of crashing.

Challenges & Highlights

Managing external API timeouts and errors taught me the importance of graceful degradation in real-world apps.
Handling environment variables securely using dotenv helped me keep sensitive data cleanly separated.
Deploying to Railway was smooth and a great way to quickly get a backend app live and accessible for testing.
Structuring the JSON response to exactly match the required schema pushed me to pay extra attention to detail.

What I Learned

How to integrate 3rd-party APIs with Axios
Managing environment variables securely
Structuring clean JSON responses
Deploying apps on Railway

GitHub Repo

Here’s the code if you’d like to see how it works:
👉 Github Repo

🙌 Thanks!

Let me know what you think! Feel free to clone it, test it, or build on top.

Forem: Rishi