DEV Community: abisoyeo

HNG Internship Stage 1: String Analyzer API

abisoyeo — Mon, 03 Nov 2025 18:16:36 +0000

For the second task in the HNG Internship, I had to build a string analysis API. The brief was simple: create a RESTful API that analyses strings, computes their properties, and stores everything in a database. It sounded straightforward at first, but it ended up being a really good exercise in backend logic, data modelling, and thinking through how users might actually query the data.

Getting Started

I went with Node.js and Express for the backend, paired with MongoDB through Mongoose. To keep things flexible, I used dotenv for environment variables and added express-rate-limit to prevent the API from being hammered with too many requests. I kept the string analysis logic modular, which made everything easier to maintain and extend down the line.

The main /strings endpoint does most of the heavy lifting. When you send it a string, it computes:

length (including spaces)
is_palindrome (ignoring case)
unique_characters count
word_count
sha256_hash for unique identification
character_frequency_map

After analysing the string, everything gets saved to MongoDB with a timestamp. This makes it easy to filter, retrieve, or delete strings later.

What the API Can Do

1. POST /strings – Analyse and store a string

This endpoint validates the input, checks if the string already exists using its sha256_hash, and returns a clean JSON response with all the computed properties.

2. GET /strings – Retrieve strings with filters

You can filter by palindrome status, length range, word count, or even check if a string contains a specific character. It's pretty flexible.

3. GET /strings/filter-by-natural-language – Query using plain language

This was probably the most interesting part to build. Instead of wrestling with query parameters, you can just ask for something like "all single word palindromic strings" or "strings containing the letter z", and the API figures out what you mean.

4. GET /strings/:value – Fetch a specific string

Pass in the original string value, and you'll get back the full analysis if it exists.

5. DELETE /strings/:value – Remove a string

Pretty self-explanatory, deletes the string from the database if you don't need it anymore.

What I Learned Along the Way

One thing I had to think carefully about was data consistency. Using a sha256 hash for each string was crucial, it guaranteed that the same string couldn't be added twice, even if someone tried submitting it multiple times.

The natural language parser was fun to build. It's not perfect, but it does a decent job of turning conversational queries into structured database filters. Testing it actually made working on the API more enjoyable.

I also spent time making sure the error handling was solid. Every endpoint returns clear, consistent HTTP status codes:

400 for malformed requests
404 when a string doesn't exist
409 when someone tries to add a duplicate

It keeps things predictable and makes the API easier to work with, whether you're building a frontend or just testing with Postman.

Takeaways

This task really drove home some important backend principles:

Keep your endpoints modular and maintainable
Always validate and sanitize user input
Handle database operations carefully
Sometimes the best UX is just letting users describe what they want in plain language

I also realized how much small design choices matter. Things like hashing strings for uniqueness or building flexible query filters might seem minor, but they make a huge difference in how robust and user-friendly the API ends up being.

Example Response

Here's what you get back when you submit a string for analysis:

{
  "id": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
  "value": "racecar",
  "properties": {
    "length": 7,
    "is_palindrome": true,
    "unique_characters": 4,
    "word_count": 1,
    "sha256_hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
    "character_frequency_map": {
      "r": 2,
      "a": 2,
      "c": 2,
      "e": 1
    }
  },
  "created_at": "2025-08-27T10:00:00Z"
}

Wrapping Up

Stage 1 felt like a step up from Stage 0. It wasn't just about building endpoints anymore, it was about thinking through data integrity, query flexibility, and making the API genuinely easy to use. It's kind of funny how something as simple as analysing strings can get surprisingly complex when you factor in storage, retrieval, and letting users filter the data however they want.

The API feels solid now, and it's a good foundation for more advanced backend work. Plus, seeing it handle complex queries with clean, consistent responses was pretty satisfying.

Building AI Co-workers That Actually Think With You

abisoyeo — Mon, 03 Nov 2025 18:15:41 +0000

I've been working on something that started simple and turned into something more interesting than I expected.

It began with a text summarizer. You know the kind: paste in a long article, get back the main points. Useful, but not exactly revolutionary. The goal was to build it as an agent using Mastra (a TypeScript agent framework), deploy it, and connect it to Telex.im (an AI agent platform like n8n, but designed as a Slack alternative for communities and bootcamps) as an AI coworker. Clean, straightforward, done.

But then I kept thinking about what else an agent could do if it wasn't just processing text in one shot. What if it could actually think through problems with you? Not just answer questions, but ask them back. Help you see angles you hadn't considered. Act less like a tool and more like someone you'd grab coffee with to talk through a decision.

That's how the Strategic Advisor agent happened.

How I Built This: The Complete Process

Let me walk you through exactly how I went from idea to deployed AI coworker.

Step 1: Setting Up Mastra

Mastra's CLI setup — from zero to agent framework in under a minute

I started by creating a new folder for the project and opening it in Visual Studio Code. Then I installed Mastra:

npm create mastra@latest

The CLI walked me through setup with a few simple prompts:

Project name
Default AI provider (I chose Google)
API key for Google Generative AI

In under a minute, Mastra had created the entire project structure, installed dependencies, and initialized everything I needed.

Clean project structure generated by Mastra - everything organized and ready to go

What I love about Mastra is how it handles the boring infrastructure so you can focus on agent logic. It gives you:

Agent orchestration - the core framework for building conversational agents with personality
Memory management using LibSQLStore - persistent conversation history that survives restarts
A2A API routes - JSON-RPC 2.0 compliant endpoints automatically generated
Development server with hot reload for instant testing

Step 2: Building the Summarizer Agent

The complete summarizer agent - just 31 lines of code for production-ready text summarization

I created my first agent in the agents folder:

export const summarizerAgent = new Agent({
  name: "Text Summarizer",
  instructions: `
    You are an expert summarization assistant.

    Main Idea: (A single sentence capturing the core thesis)
    Key Points: (2-3 bullet points with supporting details)
  `,
  model: "google/gemini-2.5-flash",
  tools: {},
  memory: new Memory({
    storage: new LibSQLStore({
      url: "file:../mastra.db"
    })
  })
});

After creating the agent, I registered it inside my main index.ts so Mastra could recognize and run it:

export const mastra = new Mastra({
  agents: { summarizerAgent },
  storage: new LibSQLStore({
    url: "file:../mastra.db"
  })
....
});

This ensures the agent is available to the Mastra runtime and ready for deployment.

The key Mastra features I'm using here:

Agent class - Mastra's core abstraction with built-in prompt management
Memory with LibSQLStore - persistent storage with zero configuration
Model abstraction - swap providers without changing code
Instruction templates - clear prompts that define agent behavior

I tested it locally by running:

npm run dev

Testing the summarizer in Mastra Studio - instant feedback on agent responses

The agent worked perfectly, taking long text and returning clean, structured summaries.

Step 3: Deploying to Mastra Cloud

To make this accessible from Telex, I needed to deploy it. Mastra Cloud made this dead simple:

Signed up at Mastra Cloud using my GitHub account
Clicked "Create New Project"
Selected the GitHub repository to deploy from

Chose the branch and specified the root folder for my project
Added the necessary environment variables (e.g., my Google API key)
Clicked "Create Project" to finish setup
After the project was created, went to the Deployments tab
Enabled deployment to get the API URL

Within minutes, my agent was live at:

https://limited-gray-house-e6958.mastra.cloud/a2a/agent/summarizerAgent

The A2A endpoints were automatically generated by Mastra's routing system. I didn't write any API boilerplate - Mastra's registerApiRoute function handles all the JSON-RPC 2.0 protocol details.

Step 4: Creating the Strategic Advisor

After the summarizer was working, I built the Strategic Advisor using the same Mastra patterns:

export const strategicAdvisorAgent = new Agent({
  name: "Strategic Advisor",
  instructions: `
    You are a strategic business advisor...

    # Your Three Core Capabilities
    1. Competitor Snapshot Analysis
    2. Decision Support Engine
    3. Idea Feasibility Evaluator

    [Detailed instructions for each capability...]
  `,
  model: "google/gemini-2.5-flash",
  tools: {},
  memory: new Memory({
    storage: new LibSQLStore({
      url: "file:../mastra.db"
    })
  })
});

Both agents share the same LibSQLStore, which means they access the same conversation history database. This is powerful for future multi-agent workflows.

Step 5: Integrating With Telex

Telex's AI Coworkers section - where agents become team members

Now comes the fun part - turning these deployed agents into AI coworkers.

I logged into Telex.im and navigated to the AI Coworkers section:

Click "Add New AI Coworker"

Creating an AI coworker - Telex even generates custom avatars

Telex includes a built-in avatar picker which you can browse and select from a range of preset faces to represent your agents.
Fill in the details:
- Name: "Text Summarizer" and "Strategic Advisor"
- Title: "Expert Summarization Specialist" and "Business Strategy & Decision Support Specialist"
- Description: Clear explanation of what each agent does
Add the workflow JSON - This is where Mastra and Telex connect:

Workflow configuration - pointing Telex to the deployed Mastra agent

{
  "active": true,
  "category": "custom-agents",
  "description": "Delegates all strategic business analysis, competitor insights, decision support, and idea feasibility evaluation requests to the external Mastra strategic advisor agent.",
  "id": "a7c9d3e2-5f8b-4a1c-9e2d-3fa8b6c4d9e1",
  "long_description": "You are a routing workflow for strategic business advisory tasks.\n\nYou delegate three types of requests to the Mastra Strategic Advisor Agent:\n\n1. **Competitor Analysis** - When users ask about competitor insights, market positioning, or competitive landscape analysis\n2. **Decision Support** - When users need help weighing options, evaluating trade-offs, or making strategic choices\n3. **Idea Feasibility** - When users want to evaluate new business ideas, features, or initiatives before investing resources\n\nYou must never perform these analyses internally. Always route requests to the 'Strategic Advisor Agent Node' via its A2A endpoint and return its structured response.\n\nThe agent will engage in conversation with the user, asking clarifying questions as needed to gather context before providing:\n- Competitor snapshots with strengths/weaknesses\n- Decision matrices with weighted factors\n- Feasibility assessments with risk/opportunity analysis\n\nSimply forward all strategic advisory requests to the Mastra agent node and relay its responses back to the user. Do not attempt to provide business advice, competitor analysis, or decision frameworks yourself.",
  "name": "strategic_advisor_agent_delegate",
  "nodes": [
    {
      "id": "c4e7f2a1-6d9b-4c3e-8f1d-5ba9c7e2d4f3",
      "name": "Strategic Advisor Agent Node",
      "parameters": {},
      "position": [400, 200],
      "type": "a2a/mastra-a2a-node",
      "typeVersion": 1,
      "url": "https://limited-gray-house-e6958.mastra.cloud/a2a/agent/strategicAdvisorAgent"
    }
  ],
  "pinData": {},
  "settings": {
    "executionOrder": "v1"
  },
  "short_description": "Routes strategic business analysis and decision support tasks to the Mastra strategic advisor agent."
}

This tells Telex: "When someone messages this AI coworker, forward the request to this Mastra endpoint using the A2A protocol."

That's it. The agents were live. Now I can engage either one in their specific agent chat.

What Worked (and What Didn't)

What worked:

Mastra made the integration process feel effortless. The API routes worked right out of the box, and testing agents through them was straightforward. Swapping agents or endpoints took seconds; it felt like having a local playground for experimentation before deployment.

What didn't:

The Telex integration gave me more trouble than expected. The workflow.json setup wasn't always consistent, and occasionally the Telex UI wouldn't update with responses from the A2A agent even though the backend call succeeded. These bugs were random and hard to reproduce, but they slowed things down a bit. Once configured, it worked, but getting there took some trial and error.

What the Strategic Advisor Actually Does

The Strategic Advisor has three core capabilities:

1. Competitor Analysis

You tell it "analyze competitors for fintech salary-advance startups in Nigeria," and instead of generic advice, it asks:

"Give me 3-5 competitor names and what each does"
"What's your differentiation?"
"What customer segment are you targeting?"

Then it builds you a structured breakdown with strengths/weaknesses tables, market positioning maps, and strategic gaps.

Structured competitor analysis - clear insights instead of generic advice

2. Decision Support

You say "should we raise seed funding now or wait 6 months?" and it asks what matters to you - speed, control, runway, risk tolerance. Then it builds a weighted decision matrix based on your priorities.

Caption: Decision framework tailored to your priorities, not generic startup advice

3. Idea Feasibility

You say "I'm thinking of building a WhatsApp bot for team feedback," and it asks about target customers, pricing, and go-to-market. Then it evaluates market fit, complexity, monetization, and risk/opportunity ratio.

Idea validation before you invest time and resources

Mastra Features That Made This Possible

Let me highlight the specific Mastra capabilities that made this project smooth:

1. Agent Orchestration

The Agent class handles prompt management, model selection, message history, and response generation. You define behavior through instructions - Mastra handles execution.

2. Memory Management

LibSQLStore provides persistent conversation history with zero configuration. Both agents share the same database, enabling cross-session context and future multi-agent workflows.

3. A2A API Routes

registerApiRoute automatically generates A2A-compliant endpoints. No API boilerplate needed - Mastra handles JSON-RPC 2.0 parsing, error handling, and response formatting.

4. Model Abstraction

Swap google/gemini-2.5-flash for anthropic/claude-3 or openai/gpt-4 without changing other code. Mastra normalizes the interface across providers.

5. Development Experience

Hot-reload server and built-in Studio UI make testing instant. Iterate on prompts and see results in seconds.

What I Learned

Conversation quality beats speed. The advisor takes longer to respond, but when you're making real decisions you need good answers, not fast ones.
Asking questions is more valuable than giving answers. The advisor's superpower isn't what it knows - it's what it asks. By forcing you to clarify what matters, it helps you see your own thinking more clearly.
Specialization scales better than generalization. Two focused agents beat one bloated agent. This is true in software, and it's true in AI.
Standards reduce friction. A2A compliance meant Telex integration took 10 minutes instead of 10 hours. Boring standards are good.
Memory turns tools into partners. When agents remember context across sessions, people stop treating them like search engines and start treating them like collaborators.
Frameworks like Mastra let you focus on what matters. I spent 90% of my time on agent logic and 10% on infrastructure. That ratio is backwards in most AI projects.

What's Next

Right now both agents work well for what they do. But there are obvious next steps:

Streaming responses for the advisor, so you see it thinking in real-time
Artifact generation - export decision matrices and reports
Tool calling - let the advisor pull in real data when needed
Multi-agent workflows - one agent delegating to another

Try It Yourself

The code is open source on GitHub. If you want to build your own version, the README has everything you need.

Built with Mastra, deployed on Mastra Cloud, integrated with Telex.im.

Documentation Links
Mastra Docs
Telex Docs

HNG Internship Stage 0: Building a Profile API with Cat Facts

abisoyeo — Fri, 17 Oct 2025 22:50:52 +0000

The first task for the HNG Internship was to build a simple RESTful API that returns my profile information along with a random cat fact. It sounds light, but it was a great way to test the fundamentals — consuming external APIs, structuring clean JSON responses, and handling dynamic data reliably.

Setting Things Up

I started by setting up a small Express server, keeping everything clean and modular. I added dotenv for environment variables and axios to handle HTTP requests. The goal was to make sure anyone could run the project locally without hardcoding personal info like my name, email, or stack.

The /me endpoint was straightforward: return a JSON response with the required fields — status, user, timestamp, and fact. I made sure the timestamp updates dynamically with each request and followed the ISO 8601 format, so everything looks consistent.

Integrating the Cat Facts API

The fun part was fetching a random cat fact from the Cat Facts API. I used axios.get() to make a request inside the /me handler.

Of course, real APIs don't always behave — so I added proper error handling and a fallback response just in case the external API fails. That way, the endpoint still returns a complete response even if the cat fact service goes down.

To protect the endpoint, I also included basic rate limiting with express-rate-limit — it's good practice for any public API, no matter how small.

Lessons Learned

Even though it's a simple endpoint, this task reminded me how much polish goes into doing things right:

Writing clean, predictable responses
Handling third-party API failures gracefully
Using environment variables properly
Keeping code readable and consistent for anyone who might review it

It also reinforced something I value in backend development — clarity over complexity. Small details like proper timestamps or helpful error messages make a huge difference.

The Final Output

Each time you hit /me, you get:

My profile info (from environment variables)
A fresh UTC timestamp
A brand-new cat fact fetched in real time

Sample Response

{
  "status": "success",
  "user": {
    "email": "abisoyeogunmona@gmail.com",
    "name": "Abisoye Ogunmona",
    "stack": "Node.js/Express"
  },
  "timestamp": "2025-10-17T20:55:12.345Z",
  "fact": "Cats sleep 70% of their lives."
}

Wrapping Up

Stage 0 was a solid start to the internship — a reminder that even small tasks can sharpen your discipline as a developer. It's not about building something huge; it's about getting the fundamentals right and paying attention to the details that make your work feel complete.