DEV Community: Sudhakar Punniyakotti

The Future of Developers: Vibe Coding and AI-Assisted Coding

Sudhakar Punniyakotti — Fri, 25 Jul 2025 15:40:30 +0000

• Code is no longer magic
• Code is no longer a story
• Code no longer bears individual artistic marks

In the LinkedIn article I start with 𝗧𝗵𝗲 𝗘𝘃𝗼𝗹𝘂𝘁𝗶𝗼𝗻 𝗼𝗳 𝗦𝗗𝗟𝗖
• 𝗧𝗵𝗲 𝗚𝗿𝗲𝗮𝘁 𝗔𝗜 𝗖𝗼𝗱𝗶𝗻𝗴 𝗗𝗶𝘃𝗶𝗱𝗲: Path Forward
• 𝗩𝗶𝗯𝗲 𝗖𝗼𝗱𝗶𝗻𝗴: The New Beginning
• 𝗔𝗜-𝗔𝘀𝘀𝗶𝘀𝘁𝗲𝗱 𝗘𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴: The Developer's Co-Pilot and Auto-Pilot
• 𝗣𝗿𝗼𝗺𝗽𝘁 𝗘𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴 𝘃𝘀 𝗖𝗼𝗻𝘁𝗲𝘅𝘁 𝗘𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴: A Critical Shift
• 𝗧𝗵𝗲 𝗡𝗲𝘄 𝗥𝗼𝗹𝗲𝘀: AI Architect and AI Engineer
• 𝗧𝗵𝗲 𝗔𝗜 𝗢𝗿𝗰𝗵𝗲𝘀𝘁𝗿𝗮𝘁𝗶𝗼𝗻 𝗪𝗼𝗿𝗸𝗳𝗹𝗼𝘄: Choosing Your Path
• 𝗖𝗵𝗼𝗼𝘀𝗶𝗻𝗴 𝗔𝗜-𝗗𝗿𝗶𝘃𝗲𝗻 𝗗𝗲𝘃𝗲𝗹𝗼𝗽𝗺𝗲𝗻𝘁: Vibe vs AI Assisted code
and end with 𝗘𝗺𝗯𝗿𝗮𝗰𝗶𝗻𝗴 𝘁𝗵𝗲 𝗲𝘃𝗼𝗹𝘂𝘁𝗶𝗼𝗻.

https://www.linkedin.com/pulse/future-developers-vibe-coding-ai-assisted-sudhakar-punniyakotti-xpnce/

MCP the API Gateway for AI Agents

Sudhakar Punniyakotti — Sun, 23 Mar 2025 00:14:38 +0000

AI agents are revolutionising industries by automating complex tasks and enabling efficient workflows. However, the effectiveness of these agents more dependent on data, systems and other agents.

The Model Context Protocol (MCP) is a standardised protocol designed to integrate smooth communication between large language models (LLMs) and services, external systems and tools.

MCP promotes a modular and scalable architecture, enabling the development of sophisticated reusable AI systems capable of performing complex tasks efficiently.

Understanding AI Agents

Before diving into MCP, it's essential to grasp the foundational concepts of AI Agents:

AI Agents: Systems that coordinate one or multiple LLMs alongside various tools to execute a series of tasks cohesively while retaining context in memory.

Workflow: AI agents follow a structured workflow comprising:

Perception: Data collection.
Planning: Deciding on a plan based on goals.
Execution: Taking actions using tools and external systems.
Monitoring: Handling outcomes and errors.
Learning: Incorporating feedback for improvement.

A significant challenge with AI agents is the necessity to individually create, integrate, and grant access to each tool and functionality. This often results in bespoke solutions tailored to specific use cases, limiting scalability and flexibility.

Current Challenges in AI Agents

Effective communication between AI agents and external systems faces several challenges,

Inconsistent Message Formats: Different agents may use unique communication protocols, making integration difficult.
Scalability Issues: Tight coupling between agents and tools can lead to bottlenecks, reducing scalability in complex tasks.
Collaboration Barriers: The lack of standardised protocols and the duplication of services lead to inefficiencies and monolithic behaviours.

Why MCP is Crucial in AI

The Model Context Protocol addresses the challenges by introducing standardised communication, modularity, scalability, and enhanced collaboration capabilities.

1. Standardised Communication

MCP is an open protocol that standardises how applications provide context to AI models, particularly large language models (LLMs). Its compared to USB-C serves as a universal standard for connecting devices, MCP offers a unified method to connect AI agents and systems to a different services and tools.

2. Modularity and Scalability

Inspired by microservices architecture, MCP enables AI agents to be modular, scalable, and reusable across different systems. Developers can build specialised agents that perform specific tasks independently, ensuring these agents can operate autonomously and integrate seamlessly into broader workflows.

3. Enhanced Collaboration

MCP defines clear ownership and responsibilities for agents, fostering cross-functional teamwork. This clarity is essential for developing complex AI systems where multiple teams work on different project aspects. MCP ensures consistency and integration across the entire system, allowing each team to focus on their specialized modules or services.

How MCP Works

Its a traditional client-server architecture with added host application as user facing. Here's a basic structure:

|- MCP Host[Chat System or Web application]

  |- MCP Client[Remote Client using SSE]
    |- MCP Server A[Database]
    |- MCP Server B[Filesystem]
    |- MCP Server C[External System]

  |-MCP Client[Stdio Client in local]
    |-MCP Server D[API system]

MCP Architecture

The MCP architecture has the following

MCP Hosts: The user application like Chat system, Agents or web application and Programs like Claude Desktop or integrated development environments (IDEs) that access data through MCP.
MCP Clients: Protocol clients maintaining one-to-one connections with servers.
MCP Servers: Dedicated servers that expose specific capabilities / existing systems / files via MCP.

Core Components of MCP

Resources: Resources represent data that MCP servers make available to clients (AI agents). These can include file contents, database records, API responses, live system data, images, and log files. Each resource is identified by a unique URI and can contain either text or binary data.
Tools: Tools are functions that MCP servers expose, allowing clients to invoke them for performing actions. Ranging from simple computations to complex API interactions, MCP supports the discovery, invocation, and management of these tools.
Prompts: Prompts are predefined templates in MCP that accept dynamic arguments, include context from resources, chain multiple interactions, and guide specific workflows. Servers can define reusable prompt templates and workflows that clients use to interact with LLMs efficiently.

Typical Workflow with MCP

Initialisation: Establishing connections and negotiating protocols and capabilities.
Message Exchange: Facilitating tools, resources, and prompt interactions through standardised MCP messages.
Termination: Graceful shutdown and resource cleanup upon completion.

Example Implementation: Maths MCP (Python)

Let's build an MCP system that provides resource, tools and prompt information in the below 10 steps

Setting Up the Environment

uv init maths-mcp
cd maths-mcp
uv venv
source .venv/bin/activate
uv add "mcp[cli]" httpx

Implementing the Server with Stdio

from mcp.server.fastmcp import FastMCP
from pathlib import Path

mcp = FastMCP("Maths MCP Server")

@mcp.resource(
    uri="dir://ubuntu/url/docs",
    name="maths_docs",
    description="List of available documents"
)
def maths_docs() -> list[str]:
    """List the files in the user's desktop"""
    docs = Path.home() / "url/docs"
    return [str(f) for f in docs.iterdir()]

@mcp.tool(
  name="addition",
  description="Add two numbers"
)
async def addition(a: float, b: float) -> float:
    """
    Add two numbers
    """
    response = a + b
    return response

@mcp.tool(
  name="subtraction",
  description="Subtract two numbers"
)
async def subtraction(a: float, b: float) -> float:
    """
    Subtract two numbers
    """
    response = a - b
    return response

@mcp.prompt(
  name="maths_prompt",
  description="Prompt for maths use cases"
)
def maths_prompt(message: str) -> str:
    prompt = "Enter two numbers to perform an operation"
    return prompt

if __name__ == "__main__":
  mcp.run()

Explanation

Two tools:

addition: Provides addition tool
subtraction: Provides subtraction tool

One resource:

maths_docs: Provides maths docs url

One prompt:

maths_prompt: Provides maths prompt

Example client code

Let's explore how a simple MCP client in Python can interact with the MCP server using stdio

from mcp import ClientSession, StdioServerParameters, types
from mcp.client.stdio import stdio_client

# Create server parameters for stdio connection
server_params = StdioServerParameters(
    command="python",  # Executable
    args=["post/stdio_server.py"],  # Command line arguments
    env=None,  # Optional environment variables
)

async def run():
  async with stdio_client(server_params) as (read, write):
    async with ClientSession(
      read, write) as session:
      # Initialize the connection
      await session.initialize()

      # List available prompts
      prompts = await session.list_prompts()
      print("\n\n\nAvailable prompts:", prompts)

      # List available resources
      resources = await session.list_resources()
      print("\n\n\nAvailable resources:", resources)

      # List available tools
      tools = await session.list_tools()
      print("\n\n\nAvailable tools:", tools)

if __name__ == "__main__":
    import asyncio
    asyncio.run(run())

Output

>python post/studio_client.py

Available prompts: meta=None nextCursor=None prompts=[Prompt(name='maths_prompt', description='Prompt for maths use cases', arguments=[PromptArgument(name='message', description=None, required=True)])]


Available resources: meta=None nextCursor=None resources=[Resource(uri=AnyUrl('dir://ubuntu/url/docs'), name='maths_docs', description='List of available documents', mimeType='text/plain', size=None, annotations=None)]


Available tools: meta=None nextCursor=None tools=[Tool(name='addition', description='Add two numbers', inputSchema={'properties': {'a': {'title': 'A', 'type': 'number'}, 'b': {'title': 'B', 'type': 'number'}}, 'required': ['a', 'b'], 'title': 'additionArguments', 'type': 'object'}), Tool(name='subtraction', description='Subtract two numbers', inputSchema={'properties': {'a': {'title': 'A', 'type': 'number'}, 'b': {'title': 'B', 'type': 'number'}}, 'required': ['a', 'b'], 'title': 'subtractionArguments', 'type': 'object'})]

Explanation

In this client example:

Initialisation: The client initialises the connection with the server by ClientSession.
Listing Tools: It retrieves a list of available tools that the server exposes.
Listing Resources: It retrieves a list of available resources that the server exposes.
Listing Prompts: It retrieves a list of available prompts that the server exposes.

This interaction demonstrates how MCP ensures that clients can dynamically discover and utilise the capabilities provided by servers, making AI agents both flexible and powerful.

SSE Server Code

On the same folder create sse_server.py and import the studio server

from starlette.applications import Starlette
from mcp.server.sse import SseServerTransport
from mcp.server import Server
from starlette.requests import Request
from starlette.routing import Mount, Route
import uvicorn
from stdio_server import mcp

def create_starlette_app(mcp_server: Server, *, debug: bool = False) -> Starlette:
  """Create a Starlette application that can server the provied mcp server with SSE."""
  sse = SseServerTransport("/messages/")

  async def handle_sse(request: Request) -> None:
    async with sse.connect_sse(request.scope, request.receive, request._send,
    ) as (read_stream, write_stream):
      await mcp_server.run(read_stream, write_stream, mcp_server.create_initialization_options(),)

  return Starlette(
    debug=debug,
    routes=[
      Route("/sse", endpoint=handle_sse),
      Mount("/messages/", app=sse.handle_post_message),
    ],
  )

if __name__ == "__main__":
  mcp_server = mcp._mcp_server
  starlette_app = create_starlette_app(mcp_server, debug=True)

  uvicorn.run(starlette_app, host="0.0.0.0", port=8000)

Explanation

In this sse server example:

The stdio_server is imported and using Starlette the endpoints /sse and /messages are exposed. Now run the server over http

Execution

post/sse_server.py
INFO:     Started server process [7553]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)

So now the MCP server is exposed in port 8000, this can be proxied by Apache or Nginx but in this example lets consider its in same host.

SSE Client Code

from mcp.client.session import ClientSession
from mcp.client.sse import sse_client
import asyncio

async def client_logic():
  async with sse_client(url="http://0.0.0.0:8000/sse") as (read, write):
    async with ClientSession(read, write) as session:
      await session.initialize()
      # List available tools
      tools = await session.list_tools()
      print("\n\n\nAvailable tools:", tools)

      resources = await session.list_resources()
      print("\n\n\nAvailable resources:", resources)

      prompts = await session.list_prompts()
      print("\n\n\nAvailable prompts:", prompts)

def main():
  asyncio.run(client_logic())

if __name__ == "__main__":
  main()

Output

>python post/sse_client.py

Available tools: meta=None nextCursor=None tools=[Tool(name='addition', description='Add two numbers', inputSchema={'properties': {'a': {'title': 'A', 'type': 'number'}, 'b': {'title': 'B', 'type': 'number'}}, 'required': ['a', 'b'], 'title': 'additionArguments', 'type': 'object'}), Tool(name='subtraction', description='Subtract two numbers', inputSchema={'properties': {'a': {'title': 'A', 'type': 'number'}, 'b': {'title': 'B', 'type': 'number'}}, 'required': ['a', 'b'], 'title': 'subtractionArguments', 'type': 'object'})]

Available resources: meta=None nextCursor=None resources=[Resource(uri=AnyUrl('dir://ubuntu/url/docs'), name='maths_docs', description='List of available documents', mimeType='text/plain', size=None, annotations=None)]

Available prompts: meta=None nextCursor=None prompts=[Prompt(name='maths_prompt', description='Prompt for maths use cases', arguments=[PromptArgument(name='message', description=None, required=True)])]

Summary

The Model Context Protocol (MCP) represents a possible solution to improve AI integrations, scaling by providing a standardised framework that ensures seamless connections between AI Agents, tools and systems.

MCP enhancing modularity, scalability, and collaboration, MCP is essential for building reusable and efficient AI systems.

References

MCP Documentation: Dive into the official MCP documentation
Experiment with MCP Development: Develop your own MCP servers and clients using the TypeScript SDK and Python SDK.

Agentic Apps: Personalised Experience for Every Customer

Sudhakar Punniyakotti — Mon, 06 Jan 2025 13:33:10 +0000

In the past, Web applications reshaped the digital landscape by providing generic, content-driven information through centralised interfaces. However, they were largely static in terms of adaptability and personalisation, constrained by predefined workflows and rigid architectures.

Later, The rise of smartphones and native mobile applications was specifically designed with user-friendly interfaces. This enhanced usability and accessibility, giving rise to a mobile-first mindset that became foundational for modern digital strategies.

Today, Generative AI and agentic systems, with their ability to adapt and generate contextual content, are driving a shift in application design—making them more specialised, modular and autonomous interactions, taking customer experiences to a new level.

Agentic Systems in Customer Support

Agentic systems are not designed to replace traditional systems and solutions; instead, they augment them by introducing decentralised, goal-oriented workflows. These systems encapsulate logic, memory, and contextual intelligence into modular components that seamlessly integrate with existing architectures.

Here’s a breakdown of their impact in technical terms:

🎨 Personalised Customer Interface and Workflow:

Agentic systems can create a personalised customer interface (UI) tailored to individual customer preferences and behaviours.
By integrating front-end microservices, the agent can dynamically adjust the UI to highlight products, offers, and content most relevant to each customer.
This integration enhances customer engagement and satisfaction by providing a seamless and customised shopping experience.

🧠 Stateful and Context-Aware Agents:

Unlike stateless API calls that rely on transient inputs, agentic systems maintain a persistent memory layer.
This layer, implemented using scalable databases or in-memory stores, tracks customer interactions, purchase histories, and behavioural patterns.
By persisting state, agents can evolve their responses and actions based on longitudinal data, achieving a high degree of personalisation.

🔄 Event-Driven Architecture:

Agentic systems excel in asynchronous and event-driven models. By leveraging messaging queues and event brokers (e.g., Kafka or RabbitMQ), they react to customer activities in real time.
For instance, an agent can proactively notify a customer about cart abandonment or anticipated restocks based on inventory signals.

🔧 Integration with Existing Tech Stacks and Microservices:

These systems are designed to operate within a microservices architecture, interfacing with CRMs, order management systems (OMS), and inventory APIs via well-defined frameworks (e.g., REST or gRPC).
This decoupled design ensures that agents remain modular and reusable across multiple customer-facing touchpoints.

⚙️ Proactive Workflow Orchestration:

Orchestration engines such as Apache Airflow or Temporal can be employed to manage agentic workflows.
These engines coordinate tasks like retrieving customer data, querying recommendation engines, and triggering notifications, ensuring that each step of the process aligns with the customer’s context and needs.

📈 Scalability and Optimisation:

Agentic systems are inherently distributed, allowing for horizontal scaling.
By leveraging containerised environments (e.g., Docker) and orchestrators like Kubernetes, businesses can deploy and manage agents with fine-grained resource allocation.
Load balancers can ensure efficient routing of customer requests to appropriate agents, maintaining high availability and performance.

Real-World Application

Consider an e-commerce platform deploying agentic systems for customer support:

Each customer is assigned a virtual agent. The agent maintains memory of their shopping preferences, transaction history, and interaction patterns using a backend database optimised for low-latency queries (e.g., DynamoDB or Redis).
When a customer engages, the agent dynamically retrieves context and personalises the interaction, such as suggesting products or offering discounts.
The agent also integrates with backend systems like the OMS and CRM to provide real-time order updates, product returns, or escalate issues to human support when needed.
Over time, the agent learns from the customer’s behaviour, fine-tuning its responses and recommendations using traditional reinforcement learning algorithms.
An agent can operate and act autonomously, managing the entire order lifecycle with one-click acceptance, followed by payment and tracking.

Some usual queries from customers:

Can I return my Hoover, which I bought last week, without a receipt?
What is the status of my order?
Please cancel my order O1312.

The agentic approach would be:

Conclusion

Agentic systems represent the next stage in the evolution of AI applications. For businesses, agentic systems offer a pathway to deliver highly personalised, scalable, and proactive customer support, ensuring a competitive edge in the ever-evolving digital landscape.

The transition to agentic-first approaches is not just a technological advancement but a strategic necessity to unlock new levels of efficiency, personalisation, and customer satisfaction—much like the shift to mobile-first paradigms over a decade ago.

Native LLM API Calls vs Agentic Approaches in GenAI

Sudhakar Punniyakotti — Tue, 24 Dec 2024 12:51:33 +0000

In the ever-evolving field of AI, the way we engage with large language models (LLMs) is shifting. While API-driven native LLM interactions focus on stateless query-response exchanges, agentic systems like CrewAI and Autogen represent a more dynamic approach, where memory, autonomy, and task orchestration.

Let’s break down how native LLM calls differ from agentic approaches and the challenges each is suited to address.

1. Native LLM Calls

In LLM interactions, users input a prompt and receive a direct response. Each call is independent, and depending on the requirements, calls may be chained one after another.

Key Features

Direct Interaction: The exchange is straightforward—users provide a query, and the model responds.
Stateless Operation: Each interaction is isolated, with no memory of past exchanges.
User-Led Workflow: The user is responsible for managing the flow of information and providing necessary context for each prompt.

Best Suited For

Simple, single-turn tasks like text generation, content summarisation, language translation, or extracting insights from data (e.g., OCR).
Scenarios requiring minimal coordination, such as chatbots or FAQ systems.

Challenges

Re-establishing context for every interaction can make it inefficient for tasks that require multiple steps.
External systems are needed to handle more intricate workflows, as LLMs do not inherently manage complex task dependencies.

2. Agentic Approaches

Agentic systems, like CrewAI, expand LLM capabilities by incorporating autonomy, memory, and task orchestration. These systems enable more sophisticated, continuous, and repeated interactions.

Key Features

Task Decomposition: Large tasks are broken down into smaller, manageable steps.
Contextual Awareness: The system can remember previous interactions, maintaining continuity across sessions and tasks.
Multi-Agent Collaboration: Multiple specialised agents may handle different aspects of a task, from planning to execution.
Goal-Oriented: The system focuses on achieving broader objectives without constant user intervention.

Best Suited For

Complex workflows requiring multiple steps or dynamic responses, such as customer support automation, research synthesis, or retrieval-augmented generation (RAG).
Scenarios where tasks evolve over time and require ongoing input from different agents working toward a shared goal.

Challenges

More complex to set up and maintain compared to simple LLM interactions.
Requires careful orchestration to manage multiple agents effectively and ensure tasks are completed efficiently.

Comparison Table

Aspect	Native LLM Calls	Agentic Approaches
Interaction Style	Direct query-response	Goal-driven, autonomous process
Context Handling	Requires repeated inputs	Maintains and leverages memory
Task Complexity	Single-turn, simple tasks	Multi-step, dynamic workflows
Decision-Making	User-directed	Independent task execution
Scalability	Limited without external logic	Scales well with multi-agent setups
Examples	Summarisation, Q&A	Contact centre automation

Limitations of Native LLMs

While LLMs are powerful tools for generating human-like text, their stateless nature requires users to manually handle continuity, making them less effective for complex, multi-turn tasks.
However, LLMs are not inherently flawed; rather, their limitations lie in how they operate within a system that doesn't handle task dependencies or evolving context.

Advantages of Agentic Systems

Agentic systems overcome the limitations of native LLMs by embedding memory and task orchestration.
These systems excel in managing interconnected tasks, where multiple objectives must be achieved, making them ideal for complex scenarios such as customer service automation, where ongoing interaction and context are essential.

Conclusion

In summary, while native LLM calls excel in simplicity and quick, stateless interactions, they fall short when tasks become complex and require continuity. Agentic systems, on the other hand, introduce autonomy and memory, making them ideal for handling multi-step, dynamic workflows.

As AI continues to evolve, the role of agentic systems in orchestrating more advanced, goal-oriented tasks will likely become more pronounced, offering deeper and more meaningful interactions in various industries.

A simple API application using Python & Flask

Sudhakar Punniyakotti — Fri, 24 Sep 2021 10:11:56 +0000

How to create a simple API application with minimal learning and clean code for beginners.

Most of the times developers create a simple frontend application that needs a couple of API's but to do that they might rely on the backend team or mock API tools like Postman or create their own.
So let us write a tiny application which covers this requirement.

Why flask?

We do have multiple choices to make a minimal API setup,

NodeJS with Express
Python with Flask or Django
C# with .Net Core or
Ruby on Rails.

We can use any of the above but I am an old friend of Ruby on Rails so chose Python with Flask for a bare minimum code. ( Actually less than 50 lines 👀)

This article doesn't intended to be production-ready code, but to make quick APIs with a database for beginners.

What we are going to cover

System setup

Project setup

Implementation

Testing the API's

Okey, lets start to code 🔥

1. System setup - prerequisites

Mac OS and Python 3.X, VS Code, Postgresql and Git.

If you are using Ubuntu then the flow will be same but need to find the equivalent commands in installation.

2. Project setup

2.1 Install / Verify the python

brew install python

Check the installation

python --version

2.2 Install virtualenv

To manage the python and dependencies across the system at least on the dev environment we must use the virtualenv

pip install virtualenv

2.3 Project initiation

Create a folder for the project

mkdir flash-sample
cd flask-sample
ls
__pycache__ env

2.4. virtualenv initialization

python -m venv env
source env/bin/activate

2.5 install SQL ORM

In this article, we will use sqlalchemy with PostgreSQL

pip install flask_sqlalchemy
pip install psycopg2

2.6 Create project requirements

python -m pip freeze requirements.txt

click==8.0.1
Flask==2.0.1
Flask-SQLAlchemy==2.5.1
greenlet==1.1.1
itsdangerous==2.0.1
Jinja2==3.0.1
MarkupSafe==2.0.1
psycopg2==2.9.1
SQLAlchemy==1.4.25
Werkzeug==2.0.1

2.7 Version control

We will use the git as version control and let's initialize

git init.
Initialized empty Git repository in /PROJECT_FOLDER/.git/

git s
  On branch master
  No commits yet
  Untracked files:
  (use "git add file..." to include in what will be committed)

  env/
  requirements.txt
  nothing added to commit but untracked files present (use "git add" to track)

Create gitignore file to remove the unwanted files tobe tracked and pushed to the repository

touch .gitignore

Add the standard gitignore file from here and make sure you add the virtualenv folder name in the gitignore.

git add.
git commit -m "Initial commit"

So the base code is ready now.

3. Implementation

As mentioned earlier in this article we are going to add two rest API endpoints to save and retrieve data using Postgresql.

Create the python file to handle our API's

touch app.py

3.1 Import section

Import required modules

from flask import Flask, request
from flask_sqlalchemy import SQLAlchemy
from flask import jsonify

3.2 setup database configurations

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql:///hands_contact'
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
db = SQLAlchemy(app)

If PostgreSQL running in a remote location then we can add the URL along with user name and password like

'postgresql://usernamr:password@server/database_name'

3.3 Define the model

Let's create a user model

class SampleUser(db.Model):
  id = db.Column(db.Integer, primary_key=True)
  first_name = db.Column(db.String(80), nullable=False)
  last_name = db.Column(db.String(120), nullable=False)

  def __init__(self, first_name, last_name):
    self.first_name = first_name
    self.last_name = last_name

3.4 Invoke the app

Let's create a module to run the application and set the database with models

if __name__ == '__main__':
  db.create_all()
  app.run()

3.5 Create the users

def creation():

  content=request.get_json(silent=True)
  try:
    db.session.add(SampleUser(content["first_name"],
    content["last_name"]))
    db.session.commit()
    return'Ok', 200
  exceptExceptionase:
    return'Invalid request', 400

The request will be converted into JSON and required parameters are loaded from there to create the user.

Finally, mound this method into the route using

@app.route("/create_users", methods=['POST'])

3.6 List users

Similar to the creation let's create a get users route as GET method.

@app.route('/users', methods=['GET'])
def home():<br /> data = []
for user in SampleUser.query.all():
  data.append(
    { "id": user.id,
      "first_name": user.first_name,
      "last_name": user.last_name
    })
  return jsonify(total_users_count=len(data), data=data, status=200)

To be basic used the jsonify but to be more proper we can use the marshmallow serializer.

Import

from flask_marshmallow import Marshmallow

Initialize

ma = Marshmallow(app)

Setup a schema that defined what are the columns needs to be constructed in JSON

class SampleUserSchema(ma.Schema):
  class Meta:
    fields = ("id", "first_name")

sample_user_schema = SampleUserSchema()
sample_user_schema = SampleUserSchema(many=True)

Now update the get users method.

@app.route('/users', methods=['GET'])
def listing():
  all_notes = SampleUser.query.all()
  return jsonify(sample_user_schema.dump(all_notes)), 200

that's it! so simple isn't it? The complete code for convenience below

from flask import Flask, request
from flask_sqlalchemy import SQLAlchemy
from flask_marshmallow import Marshmallow
from flask import jsonify

# Database ORM Configs
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql:///hands_contact'
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
db = SQLAlchemy(app)
ma = Marshmallow(app)

# User model for contact us
class SampleUser(db.Model):
  id = db.Column(db.Integer, primary_key=True)
  first_name = db.Column(db.String(80), nullable=False)
  last_name = db.Column(db.String(120), nullable=False)
  def __init__(self, first_name, last_name):
    self.first_name = first_name
    self.last_name = last_name

# JSON response serializer
class SampleUserSchema(ma.Schema):
  class Meta:
    fields = ("id", "first_name")
sample_user_schema = SampleUserSchema()
sample_user_schema = SampleUserSchema(many=True)

# Simple Dashboard
@app.route('/users', methods=['GET'])
def listing():
  all_notes = SampleUser.query.all()
  return jsonify(sample_user_schema.dump(all_notes)), 200

# Contact us POST API
@app.route("/create_users", methods=['POST'])
def creation():
  content = request.get_json(silent=True)
  try:
    db.session.add(SampleUser(content["first_name"], content["last_name"]))
    db.session.commit()
    return 'Ok', 200
  except Exception as e:
    return 'Invalid request', 400

# Invoke the application
if __name__ == '__main__':
    db.create_all()
    app.run()

4.Let's test now

Run the application from terminal

flask run

The default port for flask application is 5000 and applictaion will be listening to http://127.0.0.1:5000.

Create users using the POST endpoint /create_users with the payload

curl -X POST -d '{ "first_name": "Badsha", "last_name": "Manik" }' http://127.0.0.1:5000/create_users -H 'Content-Type: application/json' -H 'Accept: application/json'

Ok

List users using GET endpoint /users

curl http://127.0.0.1:5000/users

[{"first_name":"Vijay","id":1},{"first_name":"" 1","id":2},{"first_name":"Ajith","id":3}]

So as a starting point this single file serves the purpose but for production, as per required patterns you can split the configs, serializer, models and API methods and import wherever required.

References,
https://flask.palletsprojects.com/en/2.0.x/
https://flask.palletsprojects.com/en/2.0.x/api/
https://flask-marshmallow.readthedocs.io/en/latest/

Thank you for your time and happy learning!!!