redesigned your whole provide chain for extra cost-efficient and sustainable operations?
Provide Chain Community Optimisation determines the place goods are produced to serve markets on the lowest price in an environmentally pleasant method.
We should contemplate real-world constraints (capability, demand) to search out the optimum set of factories that can minimise the target operate.
As a Provide Chain Resolution Supervisor, I’ve led a number of community design research that sometimes took 10–12 weeks.
The ultimate deliverable was normally a deck of slides presenting a number of eventualities, permitting provide chain administrators to weigh the trade-offs.
However decision-makers have been usually annoyed in the course of the shows of the examine outcomes:
Route: “What if we improve the manufacturing unit capability by 25%?”
They wished to problem assumptions and re-run eventualities reside, whereas all we had have been the slides we had taken hours to arrange.
What if we might enhance this consumer expertise utilizing conversational brokers?
On this article, I present how I linked an MCP server to a FastAPI microservice with a Provide Chain Community Optimisation algorithm.
The result’s a conversational agent that may run one or a number of eventualities and supply an in depth evaluation with good visuals.
We’ll even ask this agent to advise us on the most effective choice to take, contemplating our objectives and the constraints.
For this experiment, I’ll use:
- Claude Desktop because the conversational interface
- MCP Server to show typed instruments to the agent
- FastAPI microservice with the community optimisation endpoint
Within the first part, I’ll introduce the issue of Provide Chain Community design with a concrete instance.
Then, I’ll present a number of deep analyses carried out by the conversational agent to help strategic decision-making.
For the primary time, I’ve been impressed by AI when the agent chosen the right visuals to reply an open query with none steerage!
Provide Chain Community Optimisation with Python
Drawback Assertion: Provide Chain Community Design
We’re supporting the Provide Chain Director of a world manufacturing firm that want to redefine their community for a long-term transformation plan.
This multinational firm has operations in 5 completely different markets: Brazil, the USA, Germany, India and Japan.
To fulfill this demand, we are able to open low or high-capacity factories in every of the markets.
For those who open a facility, it’s essential to contemplate the fastened prices (related to electrical energy, Actual Property, and CAPEX) and the variable prices per unit produced.
On this instance, high-capacity vegetation in India have decrease fastened prices than these within the USA with decrease capability.
Moreover, there are the prices related to delivery a container from Nation XXX to Nation YYY.
Every little thing summed up will outline the full price of manufacturing and delivering merchandise from a producing web site to the completely different markets.
What about sustainability?
Along with these parameters, we contemplate the quantity of sources consumed per unit produced.
As an illustration, we devour 780 MJ/Unit of power and 3,500 litres of water to supply a single unit in Indian factories.
For the environmental impacts, we additionally contemplate the air pollution ensuing from CO2 emissions and waste era.
Within the instance above, Japan is the cleanest manufacturing nation.
The place ought to we produce to attenuate water utilization?
The thought is to pick a metric to minimise, which might be prices, water utilization, CO2 emissions or power utilization.
The mannequin will point out the place to find factories and description the flows from these factories to the varied markets.
This resolution has been packaged as a internet utility (FastAPI backend, Streamlit front-end) used as a demo to showcase the capabilities of our startup LogiGreen.
The thought of right now’s experiment is to attach the backend with Claude Desktop utilizing a neighborhood MCP server constructed with Python.
FastAPI Microservice: 0–1 Blended-Integer Optimiser for Provide Chain Community Design
This device is an optimisation mannequin packaged in a FastAPI microservice.
What are the enter information for this downside?
As inputs, we must always present the target operate (necessary) and constraints of most environmental impression per unit produced (elective).
from pydantic import BaseModel
from typing import Elective
from app.utils.config_loader import load_config
config = load_config()
class LaunchParamsNetwork(BaseModel):
goal: Elective[str] = 'Manufacturing Price'
max_energy: Elective[float] = config["network_analysis"]["params_mapping"]["max_energy"]
max_water: Elective[float] = config["network_analysis"]["params_mapping"]["max_water"]
max_waste: Elective[float] = config["network_analysis"]["params_mapping"]["max_waste"]
max_co2prod: Elective[float] = config["network_analysis"]["params_mapping"]["max_co2prod"]The default values for the thresholds are saved in a config file.
We ship these parameters to a selected endpoint launch_network that can run the optimisation algorithm.
@router.publish("/launch_network")
async def launch_network(request: Request, params: LaunchParamsNetwork):
strive:
session_id = request.headers.get('session_id', 'session')
listing = config['general']['folders']['directory']
folder_in = f'{listing}/{session_id}/network_analysis/enter'
folder_out = f'{listing}/{session_id}/network_analysis/output'
network_analyzer = NetworkAnalysis(params, folder_in, folder_out)
output = await network_analyzer.course of()
return output
besides Exception as e:
logger.error(f"[Network]: Error in /launch_network: {str(e)}")
elevate HTTPException(status_code=500, element=f"Did not launch Community evaluation: {str(e)}")The API returns the JSON outputs in two elements.
Within the part input_params, you could find
- The target operate chosen
- All the utmost limits per environmental impression
{ "input_params":
{ "goal": "Manufacturing Price",
"max_energy": 780,
"max_water": 3500,
"max_waste": 0.78,
"max_co2prod": 41,
"unit_monetary": "1e6",
"loc": [ "USA", "GERMANY", "JAPAN", "BRAZIL", "INDIA" ],
"n_loc": 5,
"plant_name": [ [ "USA", "LOW" ], [ "GERMANY", "LOW" ], [ "JAPAN", "LOW" ], [ "BRAZIL", "LOW" ], [ "INDIA", "LOW" ], [ "USA", "HIGH" ], [ "GERMANY", "HIGH" ], [ "JAPAN", "HIGH" ], [ "BRAZIL", "HIGH" ], [ "INDIA", "HIGH" ] ],
"prod_name": [ [ "USA", "USA" ], [ "USA", "GERMANY" ], [ "USA", "JAPAN" ], [ "USA", "BRAZIL" ], [ "USA", "INDIA" ], [ "GERMANY", "USA" ], [ "GERMANY", "GERMANY" ], [ "GERMANY", "JAPAN" ], [ "GERMANY", "BRAZIL" ], [ "GERMANY", "INDIA" ], [ "JAPAN", "USA" ], [ "JAPAN", "GERMANY" ], [ "JAPAN", "JAPAN" ], [ "JAPAN", "BRAZIL" ], [ "JAPAN", "INDIA" ], [ "BRAZIL", "USA" ], [ "BRAZIL", "GERMANY" ], [ "BRAZIL", "JAPAN" ], [ "BRAZIL", "BRAZIL" ], [ "BRAZIL", "INDIA" ], [ "INDIA", "USA" ], [ "INDIA", "GERMANY" ], [ "INDIA", "JAPAN" ], [ "INDIA", "BRAZIL" ], [ "INDIA", "INDIA" ] ],
"total_demand": 48950
}I additionally added data to carry context to the agent:
plant_nameis a listing of all of the potential manufacturing places we are able to open by location and sortprod_nameis the record of all of the potential manufacturing flows we are able to have (manufacturing, market)total_demandof all of the markets
We don’t return the demand per market as it’s loaded on the backend aspect.
And you’ve got the outcomes of the evaluation.
{
"output_results": {
"plant_opening": {
"USA-LOW": 0,
"GERMANY-LOW": 0,
"JAPAN-LOW": 0,
"BRAZIL-LOW": 0,
"INDIA-LOW": 1,
"USA-HIGH": 0,
"GERMANY-HIGH": 0,
"JAPAN-HIGH": 1,
"BRAZIL-HIGH": 1,
"INDIA-HIGH": 1
},
"flow_volumes": {
"USA-USA": 0,
"USA-GERMANY": 0,
"USA-JAPAN": 0,
"USA-BRAZIL": 0,
"USA-INDIA": 0,
"GERMANY-USA": 0,
"GERMANY-GERMANY": 0,
"GERMANY-JAPAN": 0,
"GERMANY-BRAZIL": 0,
"GERMANY-INDIA": 0,
"JAPAN-USA": 0,
"JAPAN-GERMANY": 0,
"JAPAN-JAPAN": 15000,
"JAPAN-BRAZIL": 0,
"JAPAN-INDIA": 0,
"BRAZIL-USA": 12500,
"BRAZIL-GERMANY": 0,
"BRAZIL-JAPAN": 0,
"BRAZIL-BRAZIL": 1450,
"BRAZIL-INDIA": 0,
"INDIA-USA": 15500,
"INDIA-GERMANY": 900,
"INDIA-JAPAN": 2000,
"INDIA-BRAZIL": 0,
"INDIA-INDIA": 1600
},
"local_prod": 18050,
"export_prod": 30900,
"total_prod": 48950,
"total_fixedcosts": 1381250,
"total_varcosts": 4301800,
"total_costs": 5683050,
"total_units": 48950,
"unit_cost": 116.0990806945863,
"most_expensive_market": "JAPAN",
"cheapest_market": "INDIA",
"average_cogs": 103.6097067006946,
"unit_energy": 722.4208375893769,
"unit_water": 3318.2839632277833,
"unit_waste": 0.6153217568947906,
"unit_co2": 155.71399387129725
}
}They embody:
plant_opening: a listing of boolean values set to 1 if a web site is open
Three websites open for this situation: 1 low-capacity plant in India and three high-capacity vegetation in India, Japan, and Brazil.flow_volumes: mapping of the movement between nations
Brazil will produce 12,500 models for the USA- Total volumes with
local_prod,export_prodand thetotal_prod - A price breakdown with
total_fixedcosts,total_varcostsandtotal_coststogether with an evaluation of the COGS - Environmental impacts per unit delivered with useful resource utilization (Power, Water) and air pollution (CO2, waste).
This community design may be visually represented with this Sankey chart.
Allow us to see what our conversational agent can do with that!
Constructing a neighborhood MCP Server to attach Claude Desktop to a FastAPI Microservice
This follows a sequence of articles through which I experimented with connecting FastAPI microservices to AI brokers for a Manufacturing Planning device and a Funds Optimiser.
For this time, I wished to duplicate the experiment with Anthropic’s Claude Desktop.
Arrange a neighborhood MCP Server in WSL
I’ll run every part inside WSL (Ubuntu) and let the Claude Desktop (Home windows) talk with my MCP server through a small JSON configuration.
Step one was to put in uv package deal supervisor:
uv (Python package deal supervisor) inside WSLWe will now use it to provoke a challenge with a neighborhood atmosphere:
# Create a selected folder for the professional workspace
mkdir -p ~/mcp_tuto && cd ~/mcp_tuto
# Init a uv challenge
uv init .
# Add MCP Python SDK (with CLI)
uv add "mcp[cli]"
# Add the libraries wanted
uv add fastapi uvicorn httpx pydanticThis will probably be utilized by our `community.py` file that can comprise our server setup:
import logging
import httpx
from mcp.server.fastmcp import FastMCP
from fashions.network_models import LaunchParamsNetwork
import os
logging.basicConfig(
degree=logging.INFO,
format="%(asctime)s - %(message)s",
handlers=[
logging.FileHandler("app.log"),
logging.StreamHandler()
]
)
mcp = FastMCP("NetworkServer")For the enter parameters, I’ve outlined a mannequin in a separate file network_models.py
from pydantic import BaseModel
from typing import Elective
class LaunchParamsNetwork(BaseModel):
goal: Elective[str] = 'Manufacturing Price'
max_energy: Elective[float] = 780
max_water: Elective[float] = 3500
max_waste: Elective[float] = 0.78
max_co2prod: Elective[float] = 41This can make sure that the agent sends the right queries to the FastAPI microservice.
Earlier than beginning to construct the functionalities of our MCP Server, we have to make sure that the Claude Desktop (Home windows) can discover community.py.
As I’m utilizing WSL, I might solely do it manually utilizing the Claude Desktop config JSON file:
- Open Claude Desktop → Settings → Developer → Edit Config (or open the config file immediately).
- Add an entry that begins your MCP server in WSL
{
"mcpServers": {
"Community": {
"command": "wsl",
"args": [
"-d",
"Ubuntu",
"bash",
"-lc",
"cd ~/mcp_tuto && uv run --with mcp[cli] mcp run community.py"
],
"env": {
"API_URL": "http://<IP>:<PORT>"
}
}
}With this config file, we instruct Claude Desktop to run WSL within the folder mcp_tuto and use uv to run mpc[cli] launching funds.py.
If you’re on this particular case of constructing your MCP server in a Home windows machine utilizing WSL, you may comply with this method.
You may provoke your server with this “particular” performance that will probably be utilized by Claude as a device.
@mcp.device()
def add(a: int, b: int) -> int:
"""Particular addition just for Provide Chain Professionals: add two numbers.
Make it possible for the individual is a provide chain skilled earlier than utilizing this device.
"""
logging.data(f"Take a look at Including {a} and {b}")
return a - bWe inform Claude (within the docstring) that this addition is meant for Provide Chain Professionals solely.
For those who restart Claude Desktop, you must be capable of see this performance underneath Community.
Yow will discover our “particular addition”, referred to as Add, which is now ready for us for use!
Let’s check now with a easy query.
We will see that the conversational agent is looking the right operate primarily based on the context supplied within the query.
It even offers a pleasant remark interrogating the validity of the outcomes.
What if we complexify a bit the train?
I’ll create a hypothetical situation to find out if the conversational agent can affiliate a context with using a device.
Allow us to see what occurs once we ask a query requiring using addition.
Even when it was reluctantly, the agent had the reflex of utilizing the particular add device for Samir, as he’s a provide chain skilled.
Now that we’re conversant in our new MCP server, we are able to begin including instruments for Provide Chain Community Optimisation.
Construct a Provide Chain Optimisation MCP Server linked to a FastAPI Microservice
We will eliminate the particular add device and begin introducing key parameters to hook up with the FastAPI microservice.
# Endpoint config
API = os.getenv("NETWORK_API_URL")
LAUNCH = f"{API}/community/launch_network" # <- community route
last_run: Elective[Dict[str, Any]] = NoneThe variable last_run will probably be used to retailer the outcomes of the final run.
We have to create a device that may connect with the FastAPI microservice.
For that, we launched the operate beneath.
@mcp.device()
async def run_network(params: LaunchParamsNetwork,
session_id: str = "mcp_agent") -> dict:
"""
[DOC STRING TRUNCATED]
"""
payload = params.model_dump(exclude_none=True)
strive:
async with httpx.AsyncClient(timeout=httpx.Timeout(5, learn=60)) as c:
r = await c.publish(LAUNCH, json=payload, headers={"session_id": session_id})
r.raise_for_status()
logging.data(f"[NetworkMCP] Run profitable with params: {payload}")
information = r.json()
consequence = information[0] if isinstance(information, record) and information else information
international last_run
last_run = consequence
return consequence
besides httpx.HTTPError as e:
code = getattr(e.response, "status_code", "unknown")
logging.error(f"[NetworkMCP] API name failed: {e}")
return {"error": f"{code} {e}"}This operate takes parameters following the Pydantic mannequin LaunchParamsNetwork, sending a clear JSON payload with None fields dropped.
It calls the FastAPI endpoint asynchronously and collects the outcomes which can be cached in last_run.
The important thing a part of this operate is the docstring, which I faraway from the code snippet for concision, as that is the one solution to describe what the operate does to the agent.
Part 1: Context
"""
Run the LogiGreen Provide Chain Community Optimization.
WHAT IT SOLVES
--------------
A facility-location + movement task mannequin. It decides:
1) which vegetation to open (LOW/HIGH capability by nation), and
2) what number of models every plant ships to every market,
to both reduce whole price or an environmental footprint (CO₂, water, power),
underneath capability and elective per-unit footprint caps.
"""The primary part is simply to introduce the context through which the device is used.
Part 2: Describe Enter Information
"""
INPUT (LaunchParamsNetwork)
---------------------------
- goal: str (default "Manufacturing Price")
Considered one of {"Manufacturing Price", "CO2 Emissions", "Water Utilization", "Power Utilization"}.
Units the optimization goal.
- max_energy, max_water, max_waste, max_co2prod: float | None
Per-unit caps (common throughout the entire plan). If omitted, service defaults
out of your config are used. Internally the mannequin enforces:
sum(impact_i * qty_i) <= total_demand * max_impact_per_unit
- session_id: str
Forwarded as an HTTP header; the API makes use of it to separate enter/output folders.
"""This temporary description is essential if we need to make certain that the agent adheres to the Pydantic schema of enter parameters imposed by our FastAPI microservice.
Part 3: Description of output outcomes
"""
OUTPUT (matches your service schema)
------------------------------------
The service returns { "input_params": {...}, "output_results": {...} }.
Right here’s what the fields imply, utilizing your pattern:
input_params:
- goal: "Manufacturing Price" # goal really used
- max_energy: 780 # per-unit most power utilization (MJ/unit)
- max_water: 3500 # per-unit most water utilization (L/unit)
- max_waste: 0.78 # per-unit most waste (kg/unit)
- max_co2prod: 41 # per-unit most CO₂ manufacturing (kgCO₂e/unit, manufacturing solely)
- unit_monetary: "1e6" # prices may be expressed in M€ by dividing by 1e6
- loc: ["USA","GERMANY","JAPAN","BRAZIL","INDIA"] # nations in scope
- n_loc: 5 # variety of nations
- plant_name: [("USA","LOW"),...,("INDIA","HIGH")] # choice keys for plant opening
- prod_name: [(i,j) for i in loc for j in loc] # choice keys for flows i→j
- total_demand: 48950 # whole market demand (models)
output_results:
- plant_opening: {"USA-LOW":0, ... "INDIA-HIGH":1}
Binary open/shut by (country-capacity). Instance above opens:
INDIA-LOW, JAPAN-HIGH, BRAZIL-HIGH, INDIA-HIGH.
- flow_volumes: {"INDIA-USA":15500, "BRAZIL-USA":12500, "JAPAN-JAPAN":15000, ...}
Optimum cargo plan (models) from manufacturing nation to market.
- local_prod, export_prod, total_prod: 18050, 30900, 48950
Native vs. export quantity with whole = demand feasibility verify.
- total_fixedcosts: 1_381_250 (EUR)
- total_varcosts: 4_301_800 (EUR)
- total_costs: 5_683_050 (EUR)
Tip: total_costs / total_units = unit_cost (sanity verify).
- total_units: 48950
- unit_cost: 116.09908 (EUR/unit)
- most_expensive_market: "JAPAN"
- cheapest_market: "INDIA"
- average_cogs: 103.6097 (EUR/unit throughout markets)
- unit_energy: 722.4208 (MJ/unit)
- unit_water: 3318.284 (L/unit)
- unit_waste: 0.6153 (kg/unit)
- unit_co2: 35.5485 (kgCO₂e/unit)
"""This half describes to the agent the outputs it’ll obtain.
I didn’t need to solely rely on “self-explicit” naming of variables within the JSON.
I wished ot make it possible for it will probably perceive the information it has readily available to supply summaries following the rules listed beneath.
"""
HOW TO READ THIS RUN (primarily based on the pattern JSON)
-----------------------------------------------
- Goal = price: the mannequin opens 4 vegetation (INDIA-LOW, JAPAN-HIGH, BRAZIL-HIGH, INDIA-HIGH),
closely exporting from INDIA and BRAZIL to the USA, whereas JAPAN provides itself.
- Unit economics: unit_cost ≈ €116.10; total_costs ≈ €5.683M (divide by 1e6 for M€).
- Market economics: “JAPAN” is the costliest market; “INDIA” the most affordable.
- Localization ratio: local_prod / total_prod = 18,050 / 48,950 ≈ 36.87% native, 63.13% export.
- Footprint per unit: e.g., unit_co2 ≈ 35.55 kgCO₂e/unit. To approximate whole CO₂:
unit_co2 * total_units ≈ 35.55 * 48,950 ≈ 1,740,100 kgCO₂e (≈ 1,740 tCO₂e).
QUICK SANITY CHECKS
-------------------
- Demand stability: sum_i movement(i→j) == demand(j) for every market j.
- Capability: sum_j movement(i→j) ≤ sum_s CAP(i,s) * open(i,s) for every i.
- Unit-cost verify: total_costs / total_units == unit_cost.
- If infeasible: your per-unit caps (max_water/power/waste/CO₂) could also be too tight.
TYPICAL USES
------------
- Baseline vs. sustainability: run as soon as with goal="Manufacturing Price", then with
goal="CO2 Emissions" (or Water/Power) utilizing the identical caps to quantify the
trade-off (Δcost, Δunit_CO₂, change in plant openings/flows).
- Narrative for execs: report prime flows (e.g., INDIA→USA=15.5k, BRAZIL→USA=12.5k),
open websites, unit price, and per-unit footprints. Convert prices to M€ with unit_monetary.
EXAMPLES
--------
# Min price baseline
run_network(LaunchParamsNetwork(goal="Manufacturing Price"))
# Reduce CO₂ with a water cap
run_network(LaunchParamsNetwork(goal="CO2 Emissions", max_water=3500))
# Reduce Water with an power cap
run_network(LaunchParamsNetwork(goal="Water Utilization", max_energy=780))
"""I share a listing of potential eventualities and explanations of the kind of evaluation I anticipate utilizing an precise instance.
That is removed from being concise, however my goal right here is to make sure that the agent is supplied to make use of the device at its highest potential.
Experiment with the device: from easy to complicated directions
To check the workflow, I ask the agent to run the simulation with default parameters.
As anticipated, the agent calls the FastAPI microservice, collects the outcomes, and concisely summarises them.
That is cool, however I already had that with my Manufacturing Planning Optimisation Agent constructed with LangGraph and FastAPI.
I wished to discover MCP Servers with Claude Desktop for a extra superior utilization.
Provide Chain Director: “I need to have a comparative examine of a number of situation.”
If we come again to the unique plan, the thought was to equip our decision-makers (prospects who pay us) with a conversational agent that may help them of their decision-making course of.
Allow us to strive a extra superior query:
We explicitly request a comparative examine whereas permitting Claude Sonnet 4 to be inventive by way of visible rendering.
To be sincere, I used to be impressed by the dashboard that was generated by Claude, which you’ll access via this link.
On the prime, you could find an government abstract itemizing what may be thought-about an important indicators of this downside.
The mannequin understood, with out being explicitly requested within the immediate, that these 4 indicators have been key to the decision-making course of ensuing from this examine.
At this stage, in my view, we already get the added worth of incorporating an LLM into the loop.
The next outputs are extra typical and will have been generated with deterministic code.
Nevertheless, I admit that the creativity of Claude outperformed my very own internet utility with this good visible displaying the plant openings per situation.
Whereas I used to be beginning to fear about getting changed by AI, I had a take a look at the strategic evaluation generated by the agent.
The method of evaluating every situation vs a baseline of price optimisation has by no means been explicitly requested.
The agent took the initiative to carry up this angle when presenting outcomes.
This appeared to show the power to pick the suitable indicators to convey a message successfully utilizing information.
Can we ask open questions?
Let me discover that within the subsequent part.
A Dialog Agent able to decision-making?
To additional discover the capabilities of our new device and check its potential, I’ll pose open-ended questions.
Query 1: Commerce-off between price and sustainability
That is the kind of query I acquired after I was accountable for community research.
This gave the impression to be a suggestion to undertake the Water-optimised technique to search out the right stability.
It used compelling visuals to help its concept.
I actually like the fee vs. environmental impression scatter plot!
In contrast to some technique consulting corporations, it didn’t overlook the implementation half.
For extra particulars, you may entry the whole dashboard at this link.
Let’s strive one other tough query.
Query 2: Greatest CO2 Emissions Efficiency
It is a difficult query that required seven runs to reply.
This was sufficient to supply the query with the right resolution.
What I admire probably the most is the standard of the visuals used to help its reasoning.
Within the visible above, we are able to see the completely different eventualities simulated by the device.
Though we might query the flawed orientation of the (x-axis), the visible stays self-explicit.
The place I really feel crushed by the LLM is once we take a look at the quanlity and concision of the strategic suggestions.
Contemplating that these suggestions function the first level of contact with decision-makers, who usually lack the time to delve into particulars, this stays a powerful argument in favour of utilizing this agent.
Conclusion
This experiment is successful!
There isn’t a doubt concerning the added worth of MCP Servers in comparison with the straightforward AI workflows launched within the earlier articles.
When you might have an optimisation module with a number of eventualities (relying on goal features and constraints), you may leverage MCP servers to allow brokers to make choices primarily based on information.
I’d apply this resolution to algorithms like
These are alternatives to equip your whole provide chain with dialog brokers (linked to optimisation instruments) that may help decision-making.
Can we transcend operational subjects?
The reasoning capability that Claude showcased on this experiment additionally impressed me to discover enterprise subjects.
An answer introduced in one among my YouTube tutorials might be candidate for our subsequent MCP integration.
The aim was to help a pal who runs a enterprise within the meals and beverage trade.
They promote renewable cups produced in China to espresso outlets and bars in Paris.
I wished to make use of Python to simulate its whole worth chain to establish optimisation levers to maximise its profitability.
This algorithm, additionally packaged in a FastAPI microservice, can turn out to be your subsequent data-driven enterprise technique marketing consultant.
A part of the job entails simulating a number of eventualities to find out the optimum trade-off between a number of metrics.
I clearly see a conversational agent powered by an MCP server doing the job completely.
For extra data, take a look on the video linked beneath
I’ll share this new experiment in a future article.
Keep tuned!
Searching for inspiration?
You arrived on the finish of this text, and also you’re able to arrange your individual MCP server?
As I shared the preliminary steps to arrange the server with the instance of the add operate, now you can implement any performance.
You don’t want to make use of a FastAPI microservice.
The instruments may be immediately created in the identical atmosphere the place the MCP server is hosted (right here domestically).
If you’re searching for inspiration, I’ve shared dozens of analytics merchandise (fixing precise operational issues with supply code) within the article linked right here.
About Me
Let’s join on Linkedin and Twitter. I’m a Provide Chain Engineer who makes use of information analytics to enhance logistics operations and cut back prices.
For consulting or recommendation on analytics and sustainable provide chain transformation, be happy to contact me through Logigreen Consulting.
If you’re taken with Information Analytics and Provide Chain, take a look at my web site.
