AI: A New Partner in Our Everyday Journey

Artificial Intelligence is the science of making machines think and act like humans AI is all about building machines that can think, learn, and solve problems like humans. The purpose of AI is not to replace humans but to assist us in saving time,improving decisions, and handling routine work so we can focus on Creativity and Innovation

As the quote goes,“AI is not here to replace the humans, but to work with us and make us better”

Do You Know How Machines Learn Like Us?

Deep Learning

Deep learning is a special branch of Artificial Intelligence that teaches machines to learn from data, just like humans learn from experience.It uses a structure called neural network, inspired by how our brain’s neurons work.

Think of AI as a student. A student learns by studying examples, practicing, and correcting mistakes Machines learn in a very similar way. This learning process is what makes AI smart.

There are three main types of machine learning technology that guide AI.

Supervised Learning

In this method, machines learn from labeled data —> kind of like a teacher giving a correct answer in advance

Example: If you give a computer 1000 photos labeled “Tiger” and “Lion”, it will learn the different and then correctly identify a photo

Unsupervised Learning

Here, there’s no teacher. The machine tries to find the pattern on its own

Example: If you feed a program a lot of customer shopping data, it may group customers with similar buying habits without anyone telling it what the groups mean.

Reinforcement Learning

In this method, Machines learn by trial and error, receiving rewards for correct actions and penalties for mistakes — like learning to play a game.

Example: Training a robot to walk, teaching AI to play chess, or helping self-driving cars make safe driving decisions.

As the quote goes, “Machines are fast,but humans are wise”

Manual Workflow for CRUD Operations in HubSpot CRM

What is HubSpot CRM

HubSpot CRM is a cloud-based platform that helps Businesses manage their interactions with Customers and Contacts, and in simple terms, it helps companies work smarter, save time and build stronger Relationships with Customers.

How to Get HubSpot API Credentials and Access Token

Notes: ”The purpose of this guide is to show how to generate HubSpot API credentials and access tokens , which are required to fetch information from HubSpot using APIs. Without an access token, external applications cannot securely connect to HubSpot or retrieve data.”

Step 1: Private App (recommended for quick testing in Postman)

Use this if you only need to test calls against a single HubSpot account.

Log in to HubSpot.

Open Private Apps: Settings → Integrations → Private Apps (or go to the Private Apps area in your HubSpot account).

Create Private App: Click Create private app, give it a name / description and select the exact

Step 2: To set the Scopes based on needs

Scopes you need (e.g. crm.objects.contacts.read, crm.objects.contacts.write)Save/create.

Copy the Access Token HubSpot shows after creating the app. Save it securely (this is your Bearer token)

If you want more details about this,refer to the developer documentation I mentioned below:

Developer documentation URL : https://developers.hubspot.com/docs/reference/api/crm/objects/carts

Set the postman setup

Open Postman → New Request. Set method and URL, e.g. GET https://api.hubapi.com/crm/v3/objects/contacts?limit=10. HubSpot Developers

AUTHORIZATION: add

Authorization: Bearer <YOUR_PRIVATE_APP_TOKEN>

For POST/PATCH, also use Content-Type: application/json

Get the response 200ok

We perform CRUD operations using a UI and Python code

Create operation: How to create a Contact using HubSpot UI

Go to the Contacts section

From your HubSpot Dashboard, click Contacts in the main Navigation bar.

Choose Contacts from the dropdown.

Click Create contact

You’ll see a Create contact button

Click it to open the Create contact panel or page.

Fill in the basic required fields

These are typically:

Email

First name

Last name

Phone number

Save the contact

Click Create contact at the Bottom of the form.

HubSpot will add it to your CRM immediately, and you’ll be taken to the contacts record page.

Navigate to the page shown in the Photo Below

Create operation: How to create a Contact using Python code

Now, let’s implement a POST function in Python to create a new lead in HubSpot CRM.

import requests

def create_hubspot_contact():
    # Hardcoded HubSpot token 
    access_token = "YOUR_HUBSPOT_PRIVATE_APP_TOKEN"  # Replace with your token
    base_url = "https://api.hubapi.com"

    # Step 1: Prepare new contact data
    contact_data = {
        "firstname": "Ramesh",
        "lastname": "Kumar",
        "email": "ramesh.k@example.com",
        "phone": "+91-9876543210",
        "company": "XYZ Pvt Ltd"
    }
    payload = {"properties": contact_data}

    # Step 2: Call HubSpot API to create contact
    url = f"{base_url}/crm/v3/objects/contacts"
    headers = {
        "Authorization": f"Bearer {access_token}",
        "Content-Type": "application/json"
    }
    resp = requests.post(url, headers=headers, json=payload)
    return resp.json()

# Example usage
print(" Contact Created:", create_hubspot_contact())

Get operation: How to get a Contact using HubSpot UI

Click the Contact Navigation bar to view all the Contacts.

Get operation: How to get a Contact using Python code

Let’s create a GET function in Python to retrieve leads from HubSpot CRM.

import requests
import json

def get_all_hubspot_contacts():
    # Hardcoded HubSpot token 
    access_token = "YOUR_HUBSPOT_PRIVATE_APP_TOKEN"  #Replace with your token
    base_url = "https://api.hubapi.com"

    # Step 1: Prepare API request
    url = f"{base_url}/crm/v3/objects/contacts"
    headers = {
        "Authorization": f"Bearer {access_token}",
        "Content-Type": "application/json"
    }

    # Step 2: Call HubSpot API
    response = requests.get(url, headers=headers)

    # Step 3: Handle response
    if response.status_code == 200:
        return json.dumps(response.json(), indent=2)  # pretty JSON
    else:
        print(" Error:", response.status_code, response.text)
        response.raise_for_status()


# Example usage
    print(" All Contacts:", get_all_hubspot_contacts())

Update operation: How to update a Contact using HubSpot UI

Click contact on the left-hand navigation bar, and click on one contact

To update a contact, click on the required contact from the screen below.

In this screen, update the contact of your choice

Update operation: How to update the property or information using Python code

If you want to update each user's contacts, you applied the user ID

Let’s create an Update function in Python to modify an existing contact in HubSpot CRM.

import requests
import json

def update_hubspot_contact(contact_id: str, updated_data: dict):
    # Hardcoded HubSpot token 
    access_token = "YOUR_HUBSPOT_PRIVATE_APP_TOKEN"  #  Replace with your token
    base_url = "https://api.hubapi.com"

    #  Validate inputs
    if not updated_data:
        raise ValueError(" Error: updated_data cannot be empty.")
    
    if not contact_id:
        raise ValueError(" Error: 'contact_id' is required to update a contact.")
    
    if not isinstance(contact_id, str):
        raise ValueError(" Error: 'contact_id' must be a string inside double quotes.")

    # Step 1: Prepare request
    url = f"{base_url}/crm/v3/objects/contacts/{contact_id}"
    headers = {
        "Authorization": f"Bearer {access_token}",
        "Content-Type": "application/json"
    }
    payload = {"properties": updated_data}

    # Step 2: Call HubSpot API
    response = requests.patch(url, headers=headers, json=payload)

    # Step 3: Handle response
    if response.status_code in (200, 201):
        return json.dumps(response.json(), indent=2)
    else:
        print(" Error:", response.status_code, response.text)
        response.raise_for_status()


# Example usage
    contact_id = "201"  #  Replace with actual HubSpot contact ID
    updated_info = {
        "firstname": "Ramesh",
        "lastname": "Updated",
        "phone": "+91-9999999999"
    }
    print(" Contact Updated:", update_hubspot_contact(contact_id, updated_info))

Delete operation: How to delete a Contact using HubSpot UI

Click Contact on the left-hand navigation bar, and click on one contact check box above you see the delete icon, click it to delete the contact

Delete operation: How to delete a Contact using Python code

Let’s create a Delete function in Python to remove a Contact from HubSpot CRM.

import requests

def delete_hubspot_contact(contact_id: str):
    # Hardcoded HubSpot token 
    access_token = "YOUR_HUBSPOT_PRIVATE_APP_TOKEN"  #  Replace with your token
    base_url = "https://api.hubapi.com"

    #  Validate inputs
    if not contact_id:
        raise ValueError(" Error: 'contact_id' is required to delete a contact.")
    
    if not isinstance(contact_id, str):
        raise ValueError(" Error: 'contact_id' must be a string inside double quotes.")

    # Step 1: Prepare request
    url = f"{base_url}/crm/v3/objects/contacts/{contact_id}"
    headers = {
        "Authorization": f"Bearer {access_token}",
        "Content-Type": "application/json"
    }

    # Step 2: Call HubSpot API
    response = requests.delete(url, headers=headers)

    # Step 3: Handle response
    if response.status_code == 204:  # HubSpot returns 204 No Content for successful delete
        return f" Contact {contact_id} deleted successfully."
    else:
        print(" Error:", response.status_code, response.text)
        response.raise_for_status()


# Example usage
    contact_id = "201"  #  Replace with an actual HubSpot contact ID
    print(delete_hubspot_contact(contact_id))

Turning Python Code into an MCP Server

What is the MCP Framework

The Model Context Protocol (MCP) is an open framework designed to help AI assistants (like ChatGPT or other LLMs) Interact with external tools , APIs , and data sources in a secure and standardized way.

If you’re building an AI agent in Python ,you can use the MCP framework

Expose your custom Python functions as MCP tools

Let AI models call those functions via MCP

Connect your AI assistant to external APIs (CRM, Databases, Cloud Services)

Example: Simple MCP Server in Python

import asyncio
from mcp.server.fastmcp import FastMCP

# Create MCP server instance
mcp = FastMCP("example-server")

# Register a simple tool
@mcp.tool()
async def greet(name: str) -> str:
    """Say hello to someone"""
    return f"Hello, {name}! 

# Start MCP server
if __name__ == "__main__":
    asyncio.run(mcp.run())

Here’s what happens:

We created an MCP server called example-server

Defined a greet function as a tool

Any AI assistant that supports MCP can now call this tool

📂 A typical MCP folder structure to follow

hubspot-crm-mcp

├── .env (Environment Variables eg: HubSpot Access Token, etc.)

├── requirements.txt (Project dependencies eg: MCP SDK, requests, dotenv, etc.)

├── lead.py (Handles HubSpot Contact operations CRUD APIs)

├── hubspot_crm.py (Core HubSpot CRM API integration logic)

├── hubspot_mcp_server.py (MCP server exposing HubSpot CRM as MCP tools/resources)

├── hubspot_mcp_client.py (MCP client to interact with the server)

Please refer to the image below for understanding the MCP folder structure

ChatGPT Image Sep 8, 2025, 04_09_02 PM.png

High-level workflow

This is a Model Context Protocol (MCP) implementation for HubSpot CRM that allows natural Language interaction with HubSpots contact Management System through AI-powered routing.

Architecture & Workflow

1. Core Components

hubspot_crm.py - Base API Client

Purpose: Core HTTP client for HubSpot API interactions

Functionality:

Handles authentication via Bearer token

Provides HTTP methods (_get, post, patch, _delete)

Manages API responses and error handling

Base URL: https://api.hubapi.com

lead.py- Contact Management Layer

Purpose: Business logic for HubSpot contact operations

Key Methods:

create_contact() - Creates new contacts (requires lastname)

get_contact() - Retrieves single contact by ID

get_all_contacts() - Lists all contacts

update_contact() - Updates existing contact

delete_contact() - Removes contact

search_contact_by_email() - Finds contact by email

search_contact_by_name() - Searches by first/last name

hubspot_mcp_server.py - MCP Server

Purpose: Exposes contact operations as MCP tools

Available Tools:

get_contacts - List all contacts

get_contact_by_id - Get specific contact

create_contact - Create new contact

update_contact - Modify existing contact

delete_contact - Remove contact

get_contact_by_email - Search by email

get_contact_by_name - Search by name

hubspot_mcp_client.py - MCP Client & AI Router

Purpose: Client interface with AI-powered natural language processing

Key Features:

Uses OpenAI API for natural language understanding

Routes user questions to appropriate MCP tools

Handles argument parsing and validation

2. Complete Workflow

User Input (Natural Language)
           ↓
hubspot_mcp_client.py
           ↓
OpenAI API (GPT-4o-mini)
           ↓
LLM Router (JSON Response)
           ↓
MCP Tool Selection
           ↓
hubspot_mcp_server.py
           ↓
leads.py (Business Logic)
           ↓
hubspot_crm.py (API Calls)
           ↓
HubSpot CRM API
           ↓
Response Back to User

3. Usage Flow

User runs client with natural language question

The flow starts when the user runs the MCP client with a plain English query


 python hubspot_mcp_client.py -q "create a contact named John Doe with email john@example.com"

AI Router processes the question:

The query is sent to the AI Router, which forward it to openAI with system prompt. openAI response with a structure JSON containing the operation and its arguments

MCP Client calls the appropriate tool:

The MCP client establishes a connection to the MCP server and executes the selected operation based on the AI Router's response

Server processes the request:

The server calls the appropriate method in leads.py, validates the input data and makes the API call to HubSpot

Response flows back:

The HubSpot API response passes back through all layers until the final output is returned to the user

Key Features

Natural Language Interface: Users can ask questions in plain English

AI-Powered Routing: OpenAI handles intent recognition and parameter extraction

Comprehensive Contact Management: Full CRUD operations for contacts

Error Handling: Validation at multiple layers

Environment Configuration: Uses .env for API keys

Dependencies

MCP Framework: For tool communication

OpenAI: For natural language processing

Requests: For HTTP API calls

Python-dotenv: For environment variable management

Configuration Required

HUBSPOT_ACCESS_TOKEN in .env file

OPENAI_API_KEY in .env file

Optional: OPENAI_MODEL (defaults to "gpt-4o-mini")

Build an AI sales agent to turn HubSpot CRM into your private sales team