How Engineers Can Use AI Agents and MCP Servers to Work Smarter

Slow adoption of AI agents in AEC

AI is moving fast. New concepts like AI agents, MCPs, and RAG seem to pop up every week. And when you’re already busy with designs, client calls, and tight deadlines, who has time to keep up?

For many engineers, it’s a trade-off: do you stop to learn the latest tools, or stick to the urgent tasks in front of you—like calculations, drawings, and coordination emails? AI makes headlines daily, but clear, practical examples for engineering are still rare.

This blog is my attempt to change that. I’ll break down how AI agents actually work, how an agentic workflow comes together, and how you can build one—without needing a PhD or unlimited free time. If you’ve been curious about what AI could actually do for your work, this is a good place to start.

The key questions we will cover in this blog are:

1. What is an AI agent

2. What are agent tools

3. What is Retrieval Augmented Generation (RAG)

4. What is the Model Context Protocol (MCP)

5. What can AI agents do in engineering workflows?

6. How can you build your first agent with a MCP server?

7. How to share your agents in a web app?

1. What is an AI Agent?

An AI agent is an autonomous digital assistant that plans tasks and executes them without step by step supervision. The AI community defines agents like just a large language model (LLM) in a loop, that uses some tools and context until it meets the goal.

In practice, an agent is like a junior engineer in your office who listens to your design brief, writes the list of checks, consults references, runs the numbers, and returns with the results for your approval. The agent behaves the same way inside your computer, so you remain the senior engineer while the agent handles the routine workload.

2. What are Tools?

Tools are external functions or services that let an AI agent do more things than it could alone. Think of them as extra skills you give to your agent. For example, ChatGPT has a Code Interpreter tool that lets it run Python code in a safe and controlled environment. With this tool, ChatGPT can open files, perform math calculations, plot graphs, execute custom code, and even browse the internet. Each tool is basically a Python function that expands what the agent can do, allowing it to go beyond just generating text.

3. What is RAG?

Retrieval Augmented Generation is a process where the agent first gathers exact text from trusted sources, then builds its answer on that evidence. It augments the agent’s knowledge beyond the data used in its original training, so you can feed it standards like Eurocode, AISC, or your own company manuals. The agent can then answer questions or complete tasks using those sources, and it will cite the paragraphs it relied on, just as you would reference a clause before writing a design check.

4. What is the Model Context Protocol?

The Model Context Protocol (MCP) is an open standard that sets one format for AI agents and data servers to exchange files, queries, and tool calls.

Think of MCP as a drawing standard, there is a repeatable way to create section views, general arrangements, details, and to set dimension styles, text heights, and table styles. This consistency lets every draftsman or designer in a company produce drawings that fit smoothly into the same project.

MCP does the same thing for data. It uses one clear format to describe tools, prompts, and file resources. Think of MCP as an API for AI agents. First, the MCP server tells the agent which functions it has. Then, the agent sends inputs to the server, just like calling an API, and waits for the server to run the task. Finally, the server sends the result back to the agent and the user. This way, any MCP-compatible agent can easily connect to any MCP server without extra work.

5. What can AI agents do in engineering workflows?

Most leading LLM providers now run their models as agents. OpenAI introduced a data analysis agent in 2023, then added the code interpreter and web search tools; all three now live in the same user interface. Other providers, like Google AI Studio and Claude, also support agentic behavior in their models. You can even run MCP servers using the Claude Desktop client, allowing engineers to test agentic workflows without heavy coding.

Let’s see some use cases I frequently rely on:

Research agents for engineering and material standards

When I need to search for a topic I do not know, I find the optimal way to do this is with a “deep research” agent. ChatGPT, Grok, Google AI Studio, and DeepSeek Chat all have their own implementation of this web search agent, so it is quite accessible. You can task the agent to do thorough research for you and get back a complete answer with sources and links, so you can verify the information or just take it from there.

I recently handled a timber assessment that listed “LVL F17, LVL 13.2, and plywood" in the bill of materials. My background is concrete and steel, so in the past I would have lost hours chasing standards on Google or Eng-Tips, finding the standard that governs them and which standard I should use for reduction factor and load factor.

Using these research agents is very convenient and saves multiple hours each week, especially if you are constantly facing challenges outside your expertise.

Data analysis agent for engineering tasks

You can use a data analysis agent for a quick structural dynamic assessment: upload an Excel file with acceleration data, and the agent will then perform these tasks for you:

1. Read the file,

2. Detect the timestamp column,

3. Calculate the sampling frequency,

4. Plot the time-history signal for each channel, and

5. Plot the power spectral density (PSD) for each channel, showing the natural frequencies of the structure.

Behind the scenes the agent calls the code-interpreter tool, converts the spreadsheet to a pandas DataFrame, and uses NumPy, SciPy, and Matplotlib to generate the plots. It then offers download links for every figure and for the cleaned data file, so I can drop the results into my report without extra scripts.

More use cases for inspiration

Here are some use cases I have used in the past with agents, feel free to try them yourself.

1. Folder organizer, scans a document folder, then renames and groups files into folders like Steel Design, Concrete Design, and Datasheets. Useful when you have to organize deliverables for big engineering projects. You can achieve this by using the open-source File System MCP server at the folder and giving it clear naming rules.

2. Report proof reader, reviews engineering reports, flags spelling slips, wrong dates, or missing project details, and writes the findings in an Excel sheet, you can prompt ChatGPT by uploading the Word or PDF file and asking it to list the issues and return the results as an Excel download.

3. Drawing checker, uses a vision LLM to spot overlapping text, wrong dimensions, poor construction notes, or inconsistent revision blocks on drawings, you can implement this by loading the drawings into Google AI Studio, enabling Gemini 2 object detection, and reading the flagged items.

4. Tender assistant, loads large tender documents with RAG to quickly extract relevant information. You can upload PDF, Word, Excel, and PowerPoint files into ChatGPT, and prompt it to screen the tender requirements. It then returns the necessary details with relevant citations, saving you a lot of time.

5. Model chatbot, lets the team talk to a structural model, speeding up post processing and result extraction, you can achieve this by following the step-by-step guide I will publish soon that shows how to connect the model to a chat agent.

Next we will create a simple agent in a few lines of code and even spin up a simple MCP server so you can convert these ideas into reality!

6. How can you build your first agent with an MCP server?

This example sets up a minimal web-search tool on an MCP server and pairs it with an OpenAI-powered agent.

The project folder holds the server code, an agent launcher, a dependency list, and a .env file for your OpenAI API key. You can find a quick tutorial along with the folder structure here, so feel free to clone it or copy-paste it to your computer.

1duck_agent/ 
2├── agent_runner.py 
3├── server.py 
4├── requirements.txt 
5├── .env 
6

Start by installing the packages in requirements.txt.

1openai-agents 
2fastmcp 
3duckduckgo-search 
4python-dotenv 

Add your OpenAI key to the .env file so the agent can access OpenAI models. You can sign up at this link to get one.

OPENAI_API_KEY=sk-xxxxx 

server.py spins up a FastMCP server and registers a single tool, duck_search, which wraps the DuckDuckGo Search API.

When you run the file, the server listens on STDIO and waits for tool calls.

1from fastmcp import FastMCP 
2from duckduckgo_search import DDGS 
3
4mcp = FastMCP("DuckSearch") 
5
6@mcp.tool() 
7
8def duck_search(query: str, n_results: int = 5): 
9    with DDGS() as d: 
10        return [{"title": r["title"], "url": r["href"], "snippet": r["body"]} 
11                for r in d.text(query, max_results=n_results)] 
12
13 
14if __name__ == "__main__": 
15
16    mcp.run() 

agent_runner.py launches the agent, points it to the MCP server, and forwards the user prompt.

The agent receives the prompt, decides to call duck_search, collects the results, and returns a concise answer with links.

1import asyncio 
2import pathlib 
3from agents import Agent, Runner 
4from agents.mcp import MCPServerStdio 
5import dotenv 
6
7dotenv.load_dotenv() 
8
9
10ROOT = pathlib.Path(__file__).parent 
11
12server = MCPServerStdio(params={"command": "python", 
13                                "args": [str(ROOT / "server.py")]}, 
14                        cache_tools_list=True) 
15
16async def main(prompt: str): 
17    async with server: 
18        agent = Agent( 
19            name="Assistant", 
20            instructions="Use the tool to answer the user.", 
21            mcp_servers=[server], 
22        ) 
23
24        result = await Runner.run(starting_agent=agent, input=prompt) 
25        print(result.final_output) 
26
27if __name__ == "__main__": 
28    asyncio.run(main("How to design concrete filled HSS columns? List relevant standards")) 
29

After running python agent_runner.py in your terminal, you will see the server being launched and more responses from your LLM.

1[04/29/25 14:46:17] INFO     Starting server "DuckSearch"...                                     server.py:262 
2To design concrete-filled HSS (Hollow Structural Section) columns, consider the following standards and resources: 
31. **AISC 360-10**: This standard provides guidelines for the yield strength of bar reinforcement and composite column design. 
4   - [Details on AISC 360-10](https://steeltubeinstitute.org/resources/practical-guidance-for-concrete-filled-hss-columns/) 
52. **ASCE/SFPE 29-99**: This article provides methods for determining the fire resistance of concrete-filled HSS columns. 
6- Details on fire resistance can be found in related engineering journals.... 

You now have a working loop that joins a custom MCP tool with an AI agent. But there is more! There are a lot of public MCP servers that you can connect into the agent to increase its capabilities and maybe implement one of the ideas I showcased in the previous sections!

7. How to share your agents in a web app?

Now that you already know how to create a simple agent and connect it to an MCP server, you still have one challenge to overcome, and it is to allow your teammates to use your agents and AI workflow without having to install dependencies, share API keys, or install Python. I personally use VIKTOR.AI to host and share my AI workflows. VIKTOR allows me to create low-code web applications using a lot of input components, display the output of the agent in interactive views, and also integrate your engineering software easily. The best part is that you can deploy your web app for free and securely store API keys, so your agent can call LLM providers without issues!

Conclusion

Agents are here to stay, and it is important for all members of the AEC community to keep up with the pace of innovation. With this blog you now have a strong foundation of the knowledge you may need to leverage this technology with or without having programming skills. If you want to practice what you learned, you can challenge yourself by trying to integrate an AI agent into a web application. In a couple of minutes you can learn how to make VIKTOR apps and try to integrate agents into it!

AI in structural engineering is becoming increasingly practical, with engineers using web apps to automate design calculations, data processing, and repetitive workflows. If you're looking to streamline your engineering processes, create a VIKTOR account and start building custom automation tools tailored to your engineering challenges.