Galina Nelyubova ; Earth Day — a collection of environmental 3D illustrations

Climate emergency intensifies, and companies must play a significant role in ensuring a sustainable future. As climate change is one of the biggest systemic risks, mitigation of adverse financial effects and adaptation to rapidly changing circumstances is key for companies to ensure long-term going concern and growth. Centerpiece for these activities is proper reporting and reducing of companies’ greenhouse gas (GHG) emissions. And doing so requires much more than good intentions: it demands robust data integration, and the right platform.

Why Carbon footprint analytics matters

Every company’s operations — from logistics and manufacturing to IT and facilities — generate emissions. These emissions are environmental concerns, and they can also become a financial and reputational risk. Regulatory bodies are moving toward mandatory enterprise-wide GHG reporting, and stakeholders are demanding transparency and action.

To meet these expectations, companies must answer critical questions:

· How much GHG emissions are we responsible for?

· Which activities contribute the most?

· What’s our roadmap to a sustainable level of GHG emissions? (Ones would say “path to net-zero”, but let’s focus on reduction first before compensating).

The answers lie within the data companies already possess: financial systems, operational logs, energy consumption records… All these contain the clues needed to build a comprehensive GHG emissions profile. And here is precisely the challenge most companies are facing: transforming existing data into actionable insights.

Figure 1 — Calculating a carbon footprint is easy… until your start digging into the details!

Why it’s a data integration story

Carbon footprint analytics is fundamentally a data integration challenge. As the saying goes, “What gets measured, gets managed”. And measuring emissions accurately means harmonizing data from disparate sources, each with its own format, granularity, units, and quality. Trying to report GHG emissions without data integration is like assembling a jigsaw puzzle where pieces are taken from different puzzles: You’ll never see the full picture.

The Carbon Footprint Analytics (CFA) solution accelerator designed by Teradata tackles this complexity challenge. Based on a flexible data model, it ingests enterprise-specific data using proven algorithms, and outputs detailed GHG emissions across all scopes (1, 2 and 3) defined by the GHG Protocol.

Key capabilities include:

· Unit harmonization: automatically converts measures to configurable preferred units (pounds vs kilograms, kWh vs MWh, etc.)

Figure 2 — Automated management of measure systems heterogeneity

· Geospatial awareness: identifies the right emission factors based on location, which is particularly critical for electricity consumption (electricity mix, thus GHG emissions, significantly differ between countries and regions)

· Temporal modeling: the CFA design reflects evolving emission factors and activity periods.

A key point to understand is that CFA is not a reporting tool. It is an engine in which we can connect reporting tools. This engine integrates and enriches data to deliver a harmonized, enterprise-wide view of emissions.

Think before you jump: design matters

Before diving into carbon analytics, companies must design a robust and flexible data model. A poorly structured model can lead to wasted efforts and inconsistent results.

The CFA solution accelerator emphasizes thoughtful architecture:

· A core data model that supports multiple aggregation levels and units

· Pre-integrated calculation rules for seamless processing and explainable results

· Advanced analytics capabilities, including machine learning, geospatial, time-series and string similarities.

Figure 3 — Overview of the CFA data model, designed for scope 1, 2 and 3 GHG emissions

This foundation ensures that companies can not only report emissions, but also forecast, simulate and optimize their GHG emissions reduction strategy.

Why Teradata is the right platform

Teradata Vantage is well positioned to support Carbon Footprint Analytics:

· Geospatial capabilities: visualize GHG emissions and apply location-specific factors.

Figure 4 — Geospatial capabilities facilitate segregation of GHG emissions according to location

· Temporal intelligence: track changes over time with time-aware tables.

· Advanced analytics: leverage ClearScape Analytics™ features to observe the trends and to simulate the effect of your strategic decisions for multiple scenarios.

· Scalable integration: harmonize data from multiple sources with high performance and reliability.

Figure 5 — Multiple data sources must be efficiently integrated, both internal and external

The ClearScape Analytics Experience demo showcases CFA in action — transforming raw data into meaningful carbon insights. So, what are you waiting for? Deploy your own CFA solution accelerator, with Teradata ready to support you every step of the way.

Carbon Footprint Analytics: a data integration story was originally published in Teradata on Medium, where people are continuing the conversation by highlighting and responding to this story.

Recently I had the opportunity to host a DevTalk that focused on something many teams are actively experimenting with right now: how to reason over unstructured data using multimodal embeddings and agentic retrieval patterns.

Together with Ajay Gopalan from Unstructured.io, we walked through a live, end‑to‑end demo that shows how images, documents, and text can be brought together. The goal start from raw unstructured data and end with an experience where you can select an image, ask questions about it, and receive answers grounded in real enterprise documentation.

The full session is available on YouTube, and if you are working with vector search, multimodal models, or agentic workflows, it is worth watching the demo in full.

Below is a summary of what we covered and why it matters:

Why Multimodal Search Keeps Coming Up

Images exist everywhere in enterprise environments. They appear inside PDFs, research documents, medical records, financial reports, and technical documentation. On their own, images rarely provide enough context to answer useful questions. The surrounding text, tables, and metadata usually carry the explanation.

The challenge is connecting those pieces in a way that scales.

During the session, we framed the problem around a simple interaction. A user selects an image and asks a question. The system retrieves the relevant documentation that explains that image and uses it to produce a grounded answer. That interaction requires coordinated ingestion, embedding, storage, retrieval, and reasoning across multiple data modalities.

Structuring Unstructured Data with Unstructured

We started with ingestion, using Unstructured to process a mix of composite PDFs and standalone image files. Ajay walked through how Unstructured workflows break documents into structured elements such as text blocks, tables, and images. These elements are then enriched and prepared for downstream use.

One point that came up during the demo is how useful the Unstructured UI is during experimentation. You can design and test workflows visually, refine parsing strategies, and then transition to the API when you are ready to automate ingestion at scale. The same pipeline is used in both cases.

Storing and Searching Embeddings in Teradata VantageCloud

Once the documents and images are processed, embeddings are generated and stored inside Teradata using Enterprise Vector Store capabilities. This keeps vector search close to the rest of the enterprise data, with the same governance, access control, and operational model teams already rely on.

In the demo, we created a vector store from the generated embeddings and preserved metadata such as file names and record locators. That metadata becomes important later, when retrieved results need to be traced back to their original documents.

From a data platform perspective, this aligns well with how many teams already think about indexing. The mental model remains focused on accelerating discovery and retrieval, with similarity used as the matching mechanism instead of exact values.

Adding Agentic Reasoning on Top of Retrieval

Retrieval alone gets you relevant context. Agentic workflows turn that context into an interactive experience.

Using LangChain integrations with Teradata, we built a small set of tools that the agent can use. One tool performs similarity search over embeddings to locate the most relevant documentation for a selected image. Another tool retrieves and displays the source document associated with that result.

The agent prompt describes how these tools should be used together. When a user selects an image and asks a question, the agent retrieves the closest matching documentation and generates an answer grounded in that evidence. The reasoning step stays tied to retrieved content instead of relying on general knowledge.

During the demo, we asked questions about medical images, including tissue health and visible markers. Each response referenced information asdpulled from the most relevant documents in the library.

Observations from the Live Discussion

The audience questions touched on topics many teams are evaluating right now.

Cost considerations came up early, particularly around embeddings and multimodal models. As with most architectural decisions, the balance depends on scale and workload. Bringing vector search into the same platform as analytics removes certain integration and duplication costs that often appear with external systems.

We also discussed entry points. Multimodal search is compelling, though many teams begin with document retrieval, tables, policies, and reports. These use cases already benefit from structured parsing and vector search and provide a solid foundation before adding image‑based reasoning.

Another area of interest was familiarity. Vector stores can feel unfamiliar at first, though the underlying ideas map closely to indexing strategies DBA teams already use. Teradata’s approach keeps vector operations accessible through both SQL and Python, which helps bridge that gap.

Try the Demo Yourself

The full demo runs inside Teradata.com/experience, which is available at no cost. It includes the notebooks, ingestion pipeline, vector store setup, and agentic workflow shown during the livestream. Unstructured also provides free credits that make it easy to reproduce and extend the example.

If you are exploring multimodal embeddings, agentic retrieval patterns, or enterprise‑grade vector search, the livestream walks through the full system working together, we have also prepared a detailed blog for step by step guidance.

Building Multimodal Agentic Search Over Images and Documents — A DevTalk was originally published in Teradata on Medium, where people are continuing the conversation by highlighting and responding to this story.

The challenge of grounding the work of agentic systems

Agentic systems work across multiple steps to achieve a specific goal. Precision and predictability in achieving that goal require rich context that often goes beyond structured transactional data. Policies, procedures, diagnostics, design documents, and customer conversations are often stored as documents, PDFs, images, and audio files. When that content is transformed into embeddings, making it searchable, agents gain something closer to long-term memory: they can retrieve relevant context, cite sources, and ground their responses in what is true for the organization, making them accurate and traceable.

Most enterprise data stacks split these two worlds cleanly. Transactional facts live in relational tables. Policies, manuals, and media live somewhere else, in object storage or file systems. Bringing them together requires additional data-processing pipelines and adds governance overhead.

It is possible, though, to bridge the gap between these two worlds, and it can be done on the same platform, without data duplication, data movement overhead, and extra governance layers.

Multimodal agentic development with Teradata and Unstructured

Teradata Enterprise Vector Store has unleashed a myriad of use cases for Teradata customers, including:

• Customer 360 enrichment and contact center intelligence
• Autonomous customer insights
• Compliance and policy intelligence
• Insurance claims and contract analysis
• R&D and engineering knowledge retrieval
• Large‑scale enterprise search
• Defense and public‑sector operational intelligence

These use cases are enabled by performing vector and metadata-aware search across structured and unstructured data in a single operation, directly within the Teradata system as the single source of truth.

Teradata’s partnership with Unstructured extends these capabilities by introducing a unified multimodal ingestion and enrichment layer capable of parsing 70+ file types and generating embeddings for text and images, with audio support on the roadmap. The Unstructured pipelines handle chunking, metadata extraction, enrichment, adaptive model selection, and embedding generation, and deliver these enriched artifacts directly into Teradata’s enterprise analytics platform. The Teradata platform provides a native security model, object‑level governance, and lineage propagation. Because the Enterprise Vector Store is implemented on top of Teradata’s MPP execution framework, vector indexing, similarity search, and hybrid semantic–lexical retrieval scale transparently with other analytic and operational workloads, inheriting Teradata’s concurrency, data locality, and high‑throughput characteristics.

For development, the langchain-teradata library offers a familiar interface for incorporating Teradata Enterprise Vector Store into your agentic workflows, providing the standard agentic primitives: chat models, tools, and retrievers. The result is a single system where agents can search, and act, without the extra pipelines or governance overhead that come with stitching separate tools together.

Experience multimodal agentic development with Teradata and Unstructured

In the walkthrough that follows, we will build a life sciences image question-and-answering agent powered by Teradata Enterprise Vector Store, using data ingested and embedded by Unstructured.

The final product is an agentic system where a user can pick an image from a gallery of medical image samples and ask questions about it. The agent relies on a library of medical image documentation, finds the documentation most like the selected image, and uses it to answer the user’s question.

The process of building this agent consists of the following general steps:

• Build an ingestion and processing pipeline for composite PDF documents and images using Unstructured, which also generates the embeddings.
• Store the embeddings in Teradata’s enterprise analytics platform and index them with Teradata Enterprise Vector Store.
• Match a user‑selected image to its most similar documents using vector similarity search.
• Wrap the workflow in a LangChain agent that allows users to query the results in natural language.

Setting up your development environment

• If you haven’t already, start by creating an account at teradata.com/experience.
• Once you’re logged in, create a new environment. This ensures you’re working with the latest features and capabilities.

• Start the Jupyter Notebook environment by clicking “Run demos.”

Exploring the notebook

Setting up needed libraries and access to Teradata Enterprise Vector Store

• First, we install the packages needed.

%%capture
!pip install -r "./utils/requirements.txt" --quiet

• After restarting the kernel, we import the libraries that will power our agentic multimodal system.

# Required imports

# General imports
from teradatagenai import VSManager
from langchain_teradata import TeradataVectorStore
from teradataml import *
import os
import json
import re
import time

# Credentials and configuration management
from dotenv import load_dotenv
from getpass import getpass


#Langchain Imports
from langchain.chat_models import init_chat_model
from langchain.agents import create_agent
from langchain_core.messages import HumanMessage
from langchain.tools import tool

# Suppress warnings
import warnings
warnings.filterwarnings('ignore')
display.suppress_vantage_runtime_warnings = True

# Widget display
from IPython.display import display, HTML, IFrame
import ipywidgets as widgets

# Import utilities
from unstructured_utils.teradata_ingest import ingest
from utils.image_grid import display_image_grid

• Our trial experience provides access to a Teradata instance with Enterprise Vector Store capabilities.

ues_uri=env_vars.get("ues_uri")
if ues_uri.endswith("/open-analytics"):
  ues_uri = ues_uri[:-15]  # remove last 5 chars ("/open-analytics")

if set_auth_token(base_url=ues_uri,
         pat_token=env_vars.get("access_token"), 
         pem_file=env_vars.get("pem_file")
         ):
  print("UES Authentication successful")
else:
  print("UES Authentication failed. Check credentials.")
  sys.exit(1)

VSManager.health()
```

Ingestion and processing pipeline with Unstructured

• Unstructured offers a graphical user interface (GUI) to create workflows. The same building blocks used in the GUI are available from Unstructured API. Namely: sources, destinations, workflows, and jobs.
• Workflows orchestrate data processing between a source and a destination with steps such as partitioning, chunking, enriching, embedding, etc.
• Jobs are specific execution of a workflow.
• We have built a function that abstracts our defined workflow. The full implementation is contained in the /unstructured_utils folder and imported into the notebook.

The workflow has three sequential nodes:

1. Partitioning: Uses Claude as a vision-language model (VLM) to extract structured content from raw documents. Using a VLM rather than a traditional text extractor means it can handle complex layouts, images, and tables by “looking” at the document rather than just parsing text.
2. Chunking: Splits the partitioned content into pieces using a title-aware strategy. It targets 1,500 characters per chunk, caps at 2,048, and adds a 100-character overlap between consecutive chunks so context isn’t lost at boundaries. It also retains the original elements alongside the chunks, which is useful for traceability.
3. Embedding: Converts each chunk into a vector using Voyage AI’s multimodal model. The multimodal part matters here because the upstream VLM partitioner may have preserved image-based content, and a multimodal embedder can represent that meaningfully rather than ignoring it.

• In the notebook, we call this function to execute the ingestion of both composite PDFs and images.

ingest(api_key=unstructured_api_key, 
    td_host=env_vars.get("host"), 
    td_user=dbuser, 
    td_password=dbpwd, 
    td_database=default_db, 
    td_table='composite_pdfdocs_embedded', 
    s3_uri="s3://dev-rel-demos/teradata-unstructured/healthcare-assets/composite-pdfs/", 
    s3_anonymous=True)

ingest(api_key=unstructured_api_key, 
    td_host=env_vars.get("host"), 
    td_user=dbuser, 
    td_password=dbpwd, 
    td_database=default_db, 
    td_table='image_samples_embedded', 
    s3_uri="s3://dev-rel-demos/teradata-unstructured/healthcare-assets/images/", 
    s3_anonymous=True)

Teradata Enterprise Vector Store: The engine for processing unstructured data

• The first step to create our Vector Store is to ingest the data loaded by Unstructured into teradataml DataFrames. We can inspect a sample of the records.
• The preview displays the record_id, filename, and record_locator columns. The embedding vectors are omitted here for readability, but they are present in the underlying table and will be used for similarity search in later steps.

• Once the documents are ingested and embedded, we create a Vector Store based on the embeddings through the `TeradataVectorStore` class `from_embeddings` method. This is a class inherited from `langchain-teradata`.

vs_emb = TeradataVectorStore.from_embeddings(name = f"{default_db}_mm_embeddings_vs",
                   data = image_documentation_bank,
                   data_columns = "embeddings",
                   key_columns = ["id", "record_id"],
                   embedding_data_columns = "text",
                   metadata_columns = ["text","date_created", "date_modified", "record_locator", "filename"],)

• The Vector Store registers and creates a new vector index in VantageCloud over the embedding column, enabling sub-second approximate nearest-neighbor lookups at scale. Key parameters include the data table, the column containing the embedding vectors `data_columns`, the primary key columns for deduplication, and the metadata columns to carry through into search results.
• The `TeradataVectorStore` class includes methods for performing searches, semantical or lexical, asking questions about the results of searches (powered by an included LLM client), and to update, re-index or destroy the Vector Store.
• We can use the Vector Store to perform similarity searches between any image on the image bank and the documentation library.

In this case, we are retrieving the top record from the DataFrame containing the image data, and we perform a similarity search by vector retrieving the most similar document.

response = vs_emb.similarity_search_by_vector(data = raw_images_df.head(1), column='embeddings', top_k=1)

The match is driven by the image contained in the composite document. The retrieval returns the associated text along with metadata included when creating the Vector Store index, such as the `record_locator` and `filename`. In an agentic system, this metadata allows an agent to fetch the original document if needed, while the text provides information to answer questions about the selected image.

Teradata Enterprise Vector Store includes a built-in LLM integration that enables natural language queries over vector search results.

question='I need to recover The title, description and record id, and locator of the most similar record?'
prompt='Format the response in a conversational way.'
response = vs_emb.prepare_response(question=question, similarity_results=response, prompt=prompt)

The response object contains the requested data in the requested format as processed by the chat model included in the Teradata Enterprise Vector Store.

Based on the provided data, here is the information you requested:

Title: Image 4: Immune Cell Infiltration in Solid Tumor Tissue
Description: Microscopic image showing immune cell infiltration in solid tumor tissue. The image displays a colorful fluorescent staining pattern with bright yellow circular structures scattered throughout a predominantly pink and magenta background with blue areas. Dark black voids are visible throughout the tissue section. The staining reveals cellular structures and immune markers in the tumor microenvironment.

This image captures a solid tumor section with visible immune cell infiltration. The bright yellow circular structures likely represent lipid droplets or specific immune cell subtypes such as macrophages or dendritic cells. The dark voids may be necrotic foci or gland-like structures within the tumor. The predominant pink and magenta signals indicate widespread expression of tumor or immune markers throughout the tissue. This kind of staining is commonly used in studies examining the tumor immune microenvironment, particularly in the context of immunotherapy response.

Record ID: c724ea12-fa51–554d-b552-cb2d5de3b0a7
Record Locator: {“protocol”: “s3”, “remote_file_path”: “s3://dev-rel-demos/teradata-unstructured/healthcare-assets/composite-pdfs/”}

The capabilities we have explored unlock a lot of possibilities for an agentic system, such as the one we are building.

Building a LangChain agent powered by Teradata Enterprise Vector Store

Our agent is wrapped in a widget UI that allows users to select an image from the gallery, and a chat widget that enables conversations. These widgets are merely UI abstractions; the components of the agent itself are the same as any LangChain agent. We need a `chat_llm` component, and a set of tools.

Our trial experience includes a proxy LLM client to power the `chat_llm`, while Teradata Enterprise Vector Store includes all the functionality needed to power the core tool.

llm_key = env_vars.get("litellm_key")
llm_url = env_vars.get("litellm_base_url")

llm = init_chat_model(
  model="openai-gpt-41",
  model_provider="openai",
  base_url=llm_url,
  api_key=llm_key,
)

The main tool is a thin abstraction over the `similarity_search` and `prepare_response` methods of Teradata Enterprise Vector Store. The image grid widget is generated from the DataFrame containing the image data, and selection buttons that update the `selected_id` parameter to look up the corresponding embedding. From there, the process follows the same steps described above.

@tool
def search_similar_image_documentation(dummy: str = "") -> str:
  """
  Runs a similarity search using the currently selected image and displays
  the most similar result. Call this whenever the user asks about similar images.
  """
  if result.selected_id is None:
    return "No image is selected. Please select an image from the grid first."

  response_similarity = vs_emb.similarity_search_by_vector(
    data=raw_images_df[raw_images_df["record_id"] == result.selected_id],
    column="embeddings",
    top_k=1,
    return_type="json",
  )
  question = "I need to recover the title, description, filename, record id, and file_locator of the most similar record?"
  prompt = "Format the response as JSON object."
  response_chat = vs_emb.prepare_response(
    question=question,
    similarity_results=response_similarity,
    prompt=prompt,
  )

  with chat_output:
    display(HTML(
      f"<div style='font-family:sans-serif; padding:12px; background:#f9f9f9;"
      f"border-radius:6px; margin:8px 0;'>{response_chat}</div>"
    ))

  return response_chat

The agent itself includes specific instructions to interact with the tools and respond to the users’ intent.

You are an image analysis assistant.

Tools available:

- search_similar_image_documentation: Find images similar to a given input and retrieve associated documentation

- display_pdf_from_locator: Render a PDF document

Workflow:

1. When a user provides an image or asks for similar images, call search_similar_image_documentation

2. If the user asks to view/open a PDF from the results, extract `filename` and `remote_file_path` from the search response and pass them to display_pdf_from_locator

3. If the user asks to describe features from the image in questions like: — What are the XYZ features of this image -

a. First call search_similar_image_documentation

b. If the documentation contains relevant information, answer based on it

c. If not, inform the user that the image library documentation does not contain information to answer their question, then display the PDF using display_pdf_from_locator so they can review it directly

d. Never ask to upload the image as the user is referring to the selected image.

If a search returns no results or the PDF fields are missing, let the user know.

The widget UI and the agent enable the fully agentic experience.

Learn more about Teradata multimodal agentic capabilities.

Build the demo yourself at teradata.com/experience.

Conclusion

Bringing together Teradata Enterprise Vector Store and Unstructured creates a unified foundation for multimodal agentic systems, one where structured and unstructured data coexist naturally, governance stays simple, and developers can build advanced retrieval-augmented workflows without extra pipelines or infrastructure overhead. High-fidelity ingestion, scalable vector indexing, and agentic tooling combine into a stack that reduces the friction between experimentation and production. The walkthrough here is one example of the pattern, but the same approach applies to customer experience, automation, and context-aware intelligence across industries. As multi-modal data and agentic AI continue to expand, this integrated stack gives organizations a practical path to accurate, grounded, and enterprise-ready agentic systems built for scale.

End-to-End Multimodal RAG and Agents With Teradata and Unstructured was originally published in Teradata on Medium, where people are continuing the conversation by highlighting and responding to this story.

An autonomous enterprise is one that uses its knowledge, applies agentic reasoning, and delivers faster, higher‑quality outcomes for customers. It operates through a modern stack that unifies a knowledge layer, an intelligent agent layer, and an outcomes layer, enabling systems to reason and act with context rather than rely solely on manual workflows.

The agentic layer combines Large Language Models (LLMs) reasoning capabilities with trusted data, policies, context, and analytics, enabling agents to perform actions such as querying structured and unstructured data, executing advanced analytics, running predictions, retrieving documents, and grounding responses in enterprise reality. This connection transforms AI from experimentation into operational impact.

Teradata Enterprise MCP acts as a core pillar of this autonomy by providing secure access to data, tool standardization, context management, auditability, and high scalability for agent actions. It ensures that agents can interact with enterprise systems in a trusted, governed, and consistent way while using analytics and knowledge capabilities at production scale.

The Model Context Protocol –MCP– in brief:

MCP is an open-source standard designed to make AI systems talk to the outside world in a predictable, structured way. Instead of every developer inventing a new format for tools, capabilities, or metadata, MCP provides a common contract defining all these aspects, standardizing LLMs interactions with external tools. For a developer, this means spending more time designing the behavior of AI powered agents, not worrying about how to package or describe needed tools or necessary parameters. The protocol takes care of that for you.

Teradata research teams and a group of community contributors built the community driven Teradata MCP, this open-source effort has taken off in ways none of us fully expected. Suddenly, people were building agents that could explore data, run analytics, and automate workflows directly inside the Teradata ecosystem. The best part is that the project keeps getting better as contributors continue to refine the server, add new tools, tighten the interface, and push the boundaries of what MCP powered agents can do.

The challenges of deploying and implementing an MCP server

MCP isn’t without its challenges. While implementing an MCP server for an enterprise knowledge platform, the same questions always come up. Can it scale across teams? Can it connect to sensitive data with the right governance and privacy controls? What happens when teams start chaining servers together and bump into context‑overflow issues?

In consideration of these pain-points, Teradata has developed Teradata Enterprise MCP. Teradata Enterprise MCP tackles the core operational and governance challenges head‑on. Enabling data professionals to focus on building agents that deliver value, easing the concerns around deployment, scaling, and access controls common to MCP as a protocol.

How Teradata Enterprise MCP contributes to your Agentic AI projects

Teradata Enterprise MCP ships with a set of features that tackle common implementation challenges.

Security:

• Every user connects to Teradata Enterprise MCP using their own credentials, whether that’s basic TD2 authentication or JWT and Bearer tokens validated through the organization’s identity provider. This ensures the server only exposes the data that specific users are authorized to see, instead of routing all users through a single service account, unless the latter is the chosen implementation decision of the organization.
• RBAC controls tool visibility. MCP roles, with their corresponding assigned toolset, can be mapped to Teradata database roles so you can define exactly which tools a user can access in the system according to the user’s role.
• SQL injection protection, security scans, and end-to-end logging provide an enterprise grade security posture without adding friction for developers.

Performance:

• The server is built for multiuser, multi-session workloads with automatic connection pooling and sub second response times. Teams across the company can reliably share one MCP server without creating bottlenecks.

Tool Context Management:

• A deep catalog of more than a hundred production ready tools; from database queries and DBA functions to ML, vector search, and RAG might be difficult to manage for LLMs, however, because tool exposure is governed per role, each agent stays within a clean and compliant sandbox.

Experience Teradata Enterprise MCP

You can experience Teradata Enterprise MCP directly inside ClearScape Analytics Experience. We’ve put together a sample notebook that shows a simple LangChain integration. This is only a starting point that you can extend according to your needs.

You can easily experiment on your own by following the steps below:

Setting up your development environment

• If you haven’t used ClearScape Analytics Experience before, start by creating an account at teradata.com/experience.
• Once you’re logged in, create a new environment. This ensures you’re working with the latest features and capabilities. Take note of your chosen password as you will need it to create the MCP server configuration later.

• Start the Jupyter Notebook environment by clicking “Run demos”.

• In the Jupyter Notebook environment, open the “Getting Started” folder look for the folder named Enterprise_MCP_Data_Analyst_Agent, open the notebook inside that folder.

Exploring the notebook

• First, we install the packages needed for the MCP integration with LangChain.

pip install -U langchain langchain-mcp-adapters langchain-openai httpx

• After restarting the kernel, we import the libraries that will power our agent: asyncio for async operations, the MCP client adapter, and LangChain’s chat model and agent components.

import asyncio, sys, os, httpx
import time
from dotenv import load_dotenv
from langchain_mcp_adapters.client import MultiServerMCPClient
from langchain.chat_models import init_chat_model
from langchain.agents import create_agent
from langchain_core.messages import HumanMessage
from langchain_core.messages import AIMessage

• The notebook pulls in your environment settings from a .env file. This keeps your credentials secure and your code clean.

environment_path = "/home/jovyan/JupyterLabRoot/VantageCloud_Lake/.config/.env"
load_dotenv(dotenv_path=environment_path) 
llm_key = os.getenv('litellm_key')
llm_url = os.getenv('litellm_base_url')
username = os.getenv('username')
password = os.getenv('my_variable')

• Here we establish the connection to the Enterprise MCP Server using LangChain’s MultiServerMCPClient. The MCP server uses the credentials retrieved from the environment variables to connect on your behalf and returns the available tools.

async def get_mcp_tools():
    client = MultiServerMCPClient(
        {
            "teradata": {
                "transport": "http",
                "url": "http://host.docker.internal:8001/mcp",
                "auth": httpx.BasicAuth(username, password),
            }
        }
    )
    tools = await client.get_tools()
    return client, tools

client, tools = await get_mcp_tools()
print([t.name for t in tools])

• We initialize a chat model through the LLM proxy available in ClearScape Analytics Experience, then create a LangChain agent by passing in the Teradata MCP server tools. The system prompt tells the agent it’s a data analyst working with Teradata.

llm = init_chat_model( 
    model="openai-gpt-41", 
    model_provider="openai", 
    base_url="https://llmlite.ci.clearscape.teradata.com", 
    api_key=llm_key, ) 

agent = create_agent(
        model=llm, 
        tools=tools, 
        system_prompt=(
        ''' You are a data analyst that responds to user questions regarding data in a teradata system ''' 
        ), )

• With everything set up, you can send natural language queries to the agent. It interprets your question, picks the right MCP tools, and executes them against your Teradata environment.

user_query = input('\n What would you like to know about your data? ')
result = await agent.ainvoke(
    {"messages": [HumanMessage(content=user_query)]}
)

• The answer of the agent to this specific question is as follows:

print(result["messages"][-1].content)

ClearScape Analytics Experience is a free of cost experience with access to limited resources, for a full demo on a production grade Teradata environment feel free to reach us out at Teradata Enterprise AgentStack.

Conclusion:

The shift toward autonomous enterprises is no longer theoretical. With agentic AI, unified knowledge layers, and governed execution environments, organizations now have the foundations they need to build systems that reason, act, and deliver value with less manual intervention. The Teradata Enterprise MCP Server plays a significant role in making this real. It removes the operational and security hurdles that traditionally slow down MCP adoption and replaces them with a platform that feels stable, scalable, and ready for enterprise use. By giving teams, a secure, governed, and high‑performance way to connect LLMs and agents to trusted data, the Enterprise MCP Server frees developers and data practitioners to do what they do best: build. Whether you are exploring early prototypes, scaling agentic workloads, or preparing for production‑grade deployments, the Enterprise MCP Server provides the backbone that lets you move faster, stay compliant, and unlock the full potential of agentic AI inside your organization.

About the Author:

Daniel Herrera is Principal Developer Advocate at Teradata, specializing in AI/ML and advanced analytics. He helps developers and data practitioners unlock enterprise-scale innovation through ClearScape Analytics and VantageCloud. With deep expertise in data engineering, cloud architecture, and model deployment, Daniel bridges technical complexity with practical solutions. A frequent speaker and community contributor, he focuses on enabling scalable AI use cases across industries.

You can reach out to Daniel in LinkedIn

Introducing Teradata Enterprise MCP: Build Your First Data Analyst Agent was originally published in Teradata on Medium, where people are continuing the conversation by highlighting and responding to this story.

The introduction of the Arrow Flight SQL connector for QueryGrid® marks a significant advancement for organizations seeking to accelerate data-driven & AI-driven innovation. By enabling streamlined, high-performance access to diverse data sources without the overhead of traditional ETL processes, this capability empowers teams to unlock faster insights, enhance collaboration, and optimize their AI workflows. As a result, customers can maximize the value of their existing data infrastructure while future-proofing their operations for emerging AI and agentic workloads.

Introduction to Apache Arrow

Apache Arrow is a cross-language development platform designed for in-memory data processing. It provides a standardized columnar memory format for flat and hierarchical data, enabling efficient analytics operations. Arrow’s key strength lies in its ability to handle large datasets with minimal overhead, facilitating rapid data access and reduced memory usage. Over the last few years, Arrow has gained traction and interest in the Data Science community, with commits to its codebase added every day.

Arrow Flight and Arrow Flight SQL

Arrow Flight is an extension of Apache Arrow that introduces high-performance messaging for data transfer. It leverages gRPC to enable efficient, secure, and highly scalable data transport between systems. Building upon Arrow Flight, Arrow Flight SQL provides a protocol for executing SQL queries over Arrow Flight, allowing seamless and efficient interaction with SQL-based systems. The performance achieved is over 15 times higher than what a single-threaded protocol like JDBC can deliver (based on lab tests).

Meet QueryGrid® Arrow Flight SQL connector

QueryGrid® is a sophisticated query fabric that seamlessly connects diverse data sources and processing engines. It enables businesses to execute queries across multiple platforms, integrating disparate data environments into a unified analytical ecosystem. The integration of QueryGrid® with Arrow Flight SQL extends this capability to a broader range of engines and systems, and provides a net new capability: now client tools can also connect through the QueryGrid® Arrow Flight SQL connector. All is done leveraging Arrow’s modern and efficient data format and transport protocols, maintaining QueryGrid’s legacy: providing high-throughput parallel data exchange, and minimizing data movement when possible.

Client Server Architecture

QueryGrid® Arrow Flight SQL connector comes in two flavors: Client & Server. When the client capability is configured, the Teradata Vantage database can read data in Arrow format from other engines on the fly, without the need to copy the data upfront or perform any ETL processes (capability is available today). When the Server is configured, the Teradata Vantage database is exposed as an Arrow Flight SQL endpoint, allowing not only engines, but also tools, to read and write data in parallel, leveraging this highly efficient columnar format and transfer protocol. The server capability will be released soon, but don’t let this block you from planning how to leverage it in your future architecture; you can start the conversation with us today and see this in action.

Expanding the Ecosystem

Integrating QueryGrid® with Apache Arrow allows enterprises to tap into a wide array of data processing engines supported by Arrow Flight SQL, such as DuckDB, Dremio, and Apache Doris, just to name a few. It also allows any ADBC-compliant driver to read data from Vantage (coming soon with server capability).

Enhancements in Data Processing

QueryGrid® and Apache Arrow facilitate smooth, high-speed parallel data transfer and query execution across multiple data sources. Combined with the intelligent push-down processing that QueryGrid® provides, this enables efficient data exchange between applications, something that is key in a distributed environment.

Built for AI Workloads & Agents

The integration of QueryGrid® with Apache Arrow is particularly advantageous for AI and Agentic workloads. These workloads often require the processing of massive datasets, real-time data streaming, and the execution of complex queries. Apache Arrow’s columnar format and the high-performance transmission via Arrow Flight and Arrow Flight SQL provide the robustness and speed necessary for these demanding tasks, while also simplifying the interface between systems.

Accelerating Training and Inference

With the capability to efficiently handle large volumes of data, the integration aids in speeding up both the training and inference phases of machine learning models. Data scientists can seamlessly access and manipulate data from various sources, reducing the time spent on data preparation and transformation.

Enhanced Interoperability and Flexibility

This integration ensures that models can leverage the best-suited data processing engines, enhancing flexibility and scalability. We know that Agents are greedy and require massive amounts of data, while also the need for consolidating multiple systems. QueryGrid® Arrow Flight SQL connector exposes a simple interface for agents to efficiently grab data from multiple engines and perform complex tasks. Imagine the power you can get if you also connect this with Teradata’s and QueryGrid MCP Servers, or the Teradata AgentStack.

Conclusion

The QueryGrid® Arrow Flight SQL connector delivers high performance and seamless integration for AI and Agentic workloads. By utilizing Apache Arrow’s efficient columnar data format and high-speed transport protocols, QueryGrid® enables robust connectivity across numerous engines and systems, empowering organizations to execute advanced analytics and AI/ML tasks with ease. This integration not only streamlines data workflows but also provides agents with an efficient and unified interface to access large volumes of data from diverse sources, unlocking new possibilities in data science and machine learning.

A Gateway to Enhanced Agents & AI Workloads: Arrow Flight SQL with QueryGrid® was originally published in Teradata on Medium, where people are continuing the conversation by highlighting and responding to this story.

Let’s face it, managing large data resources can become complicated quickly. If you’re working with QueryGrid®, you already know that staying on top of your environment means juggling a lot of moving parts. Enter the QueryGrid® MCP Server Community Edition (CE), a freshly launched toolkit that’s about to make your life a whole lot easier.

What Is the QueryGrid MCP Server CE?

Think of the MCP Server CE as your new command center for all things QueryGrid® management. It’s designed to help AI assistants and other MCP clients talk directly to the QueryGrid Manager (QGM) using a standardized protocol. The focus here isn’t on querying data directly: it’s about making administrative and operational tasks faster, smarter, and more secure. And if you’re already running QueryGrid 3.x, you’re good to go; this release is fully compatible with your environment.

Key Features

• Massive Toolkit: Over 120 built-in tools support just about every QueryGrid operation you can think of: monitoring resources, adding and removing sources, tweaking configs, creating and dropping links, and tons more.
• Controlled Security: Basic authentication for QueryGrid Manager means better access control. Plus, logging is totally configurable, so you get the transparency you need.
• RESTful API Integration: Full support for Create, Read, Update, and Delete (CRUD) operations. All you need for the automation you’ve been looking for.

Why Switch to MCP Server CE?

• Boosted Efficiency: The toolkit is comprehensive and fully tested, backed by a robust API layer provided by QueryGrid® Manager service. That means even complex management tasks are handled quickly and consistently, so you can accelerate your development and deployment cycles.
• Automation is King: With the ability to programmatically manage QueryGrid® resources, you can automate all your admin workflows — whether through chatbots, agents, or other tools — and get back to the fun stuff.
• Built-in Security: Only authorized users or systems can make changes, thanks to secure authentication mechanisms.
• Ready for Scale: Built for production from the ground up, with configurable logging for transparency and traceability. Start with small projects and climb to mission-critical deployments.

Takeways

Whether you’re a developer, data engineer, DBA, or someone who wants smoother QueryGrid® management, the QueryGrid® MCP Server Community Edition is a game-changer. It’s secure, flexible, and packed with features that will make your admin processes more efficient and reliable. If you’re ready to embrace modern automation and development practices, this toolkit deserves a spot in your environment. And remember, you can expand the power of this freshly released server with Teradata’s MCP Server Community Edition.

Start your journey now by downloading your copy from Teradata GitHub.

Why You’ll Want QueryGrid® MCP Server Community Edition in Your Toolkit was originally published in Teradata on Medium, where people are continuing the conversation by highlighting and responding to this story.

Introduction

The way customer data systems are built is undergoing a remarkable transformation. Across the industry, significant milestones have been reached — unified Customer 360 views, sophisticated machine learning (ML) models, and real-time streaming pipelines. These foundations set up the next leap: systems that don’t just analyze customer behavior, but actively shape experiences in real time.

The Teradata Customer Intelligence Framework represents this next generation of customer intelligence architecture. Built on established data engineering and machine learning practices, it enables autonomous, real-time decision-making. The framework equips data scientists, data engineers, ML engineers, and platform architects to create systems that sense needs, understand context, and take immediate action; powered by AI for CX that delivers measurable business impact.

The challenge

Modern customer data architectures hit the same three walls repeatedly. Data lives in disconnected systems, making a reliable Customer 360 fragile at best. Batch-heavy pipelines introduce latency, so insights arrive after the moment has passed. And unresolved customer tasks often escalate to costly channels, driving up operations while eroding satisfaction.

The Customer Intelligence Framework addresses these limits with an event-driven approach: unify raw streams into reusable data products, detect signals that carry business meaning in real time, and trigger guard-railed agent decisions that act immediately. In short, move from fragmented data and delayed reports to a closed loop that senses, decides, and acts.

Architecture: from data to intelligence

The Customer Intelligence Framework transforms raw data into autonomous intelligence through three core components working across five integrated layers:

Foundational Elements

• Data products — Reusable, structured assets that organize complex customer data. These multi-dimensional building blocks can be assembled differently for various use cases, with full version control and API accessibility via REST, Python SDKs, or SQL.
• Signals — Real-time patterns detected from customer behavior, not just transactions. The framework continuously identifies meaningful events like engagement drops, anomalous patterns, or service escalations, enabling immediate response rather than batch processing.
• Agents — Intelligent entities that autonomously execute decisions within configured guardrails. These agents operate across the end-to-end framework — from data orchestration and feature engineering to signal detection and service activation. They provide natural language interfaces, coordinate with other agents, and maintain full audit trails of their reasoning and actions.

Architecture Components

• Data ingestion. Structured, semi-structured, and unstructured sources land through streaming, ETL, object storage, and APIs; catalogued for lineage.
• Feature engineering (in-database). Transform inputs into robust features and vector representations close to the data to minimize movement.
• Models and rules. Hybrid decisioning blends ML models, heuristics, and policy rules to balance accuracy, cost, and control.
• Signal processing. Detect, evaluate, and fuse patterns; a semantic layer maps technical signals (scores, thresholds, sequences) to business concepts (intent, risk, opportunity).
• Service activation (VCX). Publish decisions and signals via pub/sub so downstream applications subscribe to just-in-time intelligence (NBA/NBO, retention, remediation). Outcomes flow back for continuous learning.

The architecture flows from data ingestion (supporting structured, semi-structured, and unstructured sources) through features engineering and model deployment using ClearScape Analytics® for in-database execution.

Signal processing interprets these patterns through a semantic layer that maps technical signals to business concepts, while the service activation layer, powered by Teradata VCX, streams real-time intelligence to downstream applications via publish/subscribe patterns.

Key technical advantages:

• Industry Data Models provide pre-built schemas for rapid deployment
• In-database processing eliminates data movement overhead
• Multi-model orchestration combines rules, ML models, and heuristics
• Every application can subscribe to relevant signals via REST APIs

Customer lifetime value multi-agent system demo

This demo shows how autonomous customer intelligence turns CLV forecasting and growth into a production workflow. The multi-agent system runs in Teradata AgentBuilder, keeps computation inside Teradata Vantage, and analyzes historical behavior directly in-database. LLMs — GPT-4.1 (routing/response) and Claude Sonnet-4 (analysis/strategy), drive intent understanding, exploration, and decisioning, combining reasoning with real-time signals to answer questions like “Which customer type has the highest CLV and why?” and to recommend next-best actions that lift retention and cross-sell.

The implementation uses Flowise inside AgentBuilder for low-code composition; the pattern is integration-friendly and supports additional connectors.

In the multi-agent system architecture, a request enters at “Start”, the conditional agent classifies intent, and exactly one specialist is selected — data exploration, insights generator, or strategic reasoning. The “check if chart required” gate then decides whether a visual adds clarity. If a chart is warranted, the “Visualization Agent” prepares a spec and a custom JavaScript function renders the graphic using Teradata plotting; otherwise, the LLM node composes a concise text response. The result is a governed path from question to decision, with visuals used only when they improve understanding.

The multi-agent system includes the following nodes:

• Start node: Initializes the run by capturing the user’s input and shared context (customer/segment, time window, policy flags) for downstream nodes.
• Condition agent nodes: Route the flow based on intent (exploration/insights/strategy) and presentation needs (whether a chart is required).
• Agent nodes: Execute scoped tasks — data exploration, insight generation, strategic reasoning, and visualization using Teradata MCP tools against Vantage with clear guardrails.
• LLM node: Composes the final, business-ready response by fusing agent outputs, rationale, KPIs, and (if present) a chart caption.
• Custom function node: Renders artifacts like charts from a validated spec and returns an embeddable image/URI for the response.

Let’s look at the flow of the whole system!

Start node

The start node initializes the flow, captures the user’s input (chat or form) and sets shared variables — question, optional customer/segment, time window, table handles, and policy flags, for all downstream nodes.

Condition agent node: intent identification agent

The Intent Identification Agent is the first of the two condition-agent nodes in the system. It decides which agent to call from the three available specialists, based on the scenario expressed in the user’s query.

There are three scenarios:

• User is asking for basic details about tables, databases, columns, etc.
  - Routes to Data Exploration Agent
• User is asking about banking churn, customer lifetime value, CLV, correlation, sentiments analysis, charts like pie chart, histogram etc.
  - Routes to Insights Generator Agent
• User is asking about recommendation to reduce the churn, what are the main factors leading to a churn or low CLV, recommend me method to reduce churn, which are the important factor for churn.
  - Routes to Strategic Reasoning Agent

Based on the prompt instructions, an LLM such as Azure ChatOpenAI (GPT-4.1) interprets the intent, selects the appropriate scenario, and triggers the corresponding agent node. The model can be chosen per task; in this agent node, GPT-4.1 is used and configured with an API key (plus endpoint/deployment where applicable).

Agent node: data exploration agent

Reports what data is available (e.g., databases/tables, key columns, grain, joins, and freshness) and can return small, PII-safe previews using Teradata MCP tools against Vantage.

The LLM used here is Anthropic Claude Sonnet 4; it can be configured the same way as GPT-4.1. All access to LLMs is provided through a cloud service provider. The specific models available, along with credentials and base URLs, depend on the deployment of Teradata and AgentBuilder.

Access to the Teradata MCP server is configured through the “Tool” panel. As with LLM integration, the connection URL and credentials depend on the specific deployment of Teradata and AgentBuilder.

Providing the right tools via Teradata MCP is critical for accurate LLM outputs. Select and scope these tools in the “Available Actions” panel so each agent can call exactly what it needs for governed, reliable results.

Tools can only be selected under Available Actions once MCP server is configured.

Agent node: insight generator agent

Interprets the question and derives findings only from the governed data, following a reasoning-first workflow: quick data checks (columns, types, missingness), method selection (aggregations, correlations, simple tests), and a brief rationale. It performs the calculation, not just a description, and explains the process before stating results.

For simple scalar asks, it stays concise; for richer questions, it returns a compact business summary. Output is markdown with “Reasoning” and “Conclusion” sections for clarity and reuse.

The LLM and MCP configurations mirror the Data Exploration Agents configuration, with the addition of Sentiment Extractor in Available Actions when needed.

Agent node: strategic reasoning agent

Converts analytical findings into actionable churn-reduction strategies by reviewing feature importance, explaining how key factors drive attrition, and prioritizing where to intervene. It proposes evidence-based methods (e.g., onboarding improvements, complaint triage, targeted cross-sell) and links each recommendation to the contributing drivers with clear rationale and guardrails. Responses are concise and structured in markdown with an intro, numbered reasoning steps, recommended methods to reduce banking churn, and a brief summary of the highest-impact actions.

The MCP and LLM configuration remains the same, with only changes in MCPs Available Actions.

Condition agent: check if chart required

Decides whether the answer needs a visualization or should remain textual. It inspects the prompt and, only when the user asks to plot, selects a chart type from Line, Polar, Pie, or Radar; single-value outputs (e.g., corr: 0.89) skip charts. If a valid chart is warranted, it passes a clean spec to the Visualization Agent and Custom Function to render, otherwise it defaults to a table or plain response and routes directly to the “Generate Response” LLM node.

The LLM configuration mirrors the earlier condition agent, this node takes the question as input and chooses between two scenarios — chart-related or general. If chart required is selected, it triggers the Visualization Agent to plot a graph, otherwise, it returns a straightforward textual output.

LLM node: generate response

Composes the final, business-ready answer using the context passed from upstream agents, focusing on clear reasoning and actionable guidance (no code). It identifies the domain of the ask (visualization, tables, churn reduction, database design), applies best-practice logic, and balances detail with brevity for simple scalar questions. The output is 2–4 tight paragraphs that explain the “why,” list concrete next steps, note caveats, and tie recommendations to measurable impact.

For clean presentation, Return Response As is set to Assistant Message.

Agent node: visualization agent

Emits a strict JSON payload — no prose, notes, or code. If unsure about columns, it first verifies with MCP tools before invoking any chart tools. When a chart is needed, it returns only this structure:

{ "type": "<line|polar|pie|radar>", "title": "<chart title>", "labels": […], "datasets": […] }

If a chart isn’t appropriate, it returns JSON for a simple table instead, without adding or removing fields or including extra text.

Teradata MCP Available Actions include Teradata plotting tools that help generate the requested visual.

It can generate four chart types:

• Line — trends over time (e.g., weekly churn rate by segment)
• Polar — circular comparison of magnitudes (e.g., complaints by category)
• Pie — part-of-whole (e.g., share of customers by risk tier)
• Radar — multi-metric profile (e.g., cohort scores across engagement, spend, friction)

Custom function: draw function

The Draw Function turns the Visualization Agent’s JSON into a live chart. It expects a clean payload with type, title, labels, and datasets; if that structure is present, it renders an embedded Chart.js graphic in an iframe. If the input isn’t valid chart data (or the task doesn’t require a chart), it gracefully falls back to a plain message instead of breaking the flow. Supported chart types match the gating node: line, polar, pie, and radar.

To wire it in the flow, pass the Visualization Agent’s output to the function as “input_data = {{$flow.state.main_vis_op}}”. The function parses that value, validates that labels and datasets are arrays, and then builds the chart with the provided title. If validation fails, the function simply returns the text it received (e.g., “No chart needed”), keeping responses clean and predictable.

This approach keeps rendering logic outside the agents, avoids code in the final answer, and ensures visuals appear only when they add clarity, everything else stays fast, lightweight, and easy to audit.

Output

The CLV multi-agent system tailors each response to the question — returning plain, business-ready text when a single number suffices (e.g., “What is the average CLV?” → $412.37), and a chart when it adds clarity. Two quick examples from the demo:

• Text only ask: “What is the average value of CLV”
  - Flow: Start → Intent Identification Agent → Insights Generator Agent → Generate Response

The assistant computes the mean CLV in-database and returns a concise explanation (no visualization).

• Visualization ask: “Create a visualization for average value of balance and CLV”
  - Flow: Start → Intent Identification Agent → Insights Generator Agent → Check if chart required → Visualization Agent → Draw Function

The chart gate detects a plotting request, the Visualization Agent emits a JSON spec, and the Draw Function renders a bar chart.

Every response is traceable, the process flow shows which nodes executed, and the output links back to the data and policies used. Visuals appear only when requested or clearly helpful, otherwise, the answer stays fast, readable, and ready to act on.

Conclusion

Teradata’s Customer Intelligence Framework closes the loop from data → signal → activation. Data remains governed in Vantage; signals are detected and interpreted in real time; and activation happens through guard-railed next-best actions that are explainable and measurable. Built in AgentBuilder, the CLV demo shows autonomous customer intelligence in practice: agents understand intent, assemble evidence, and trigger the right response — text for simple answers, visuals when they add clarity, and recommendations when action is warranted.

The pattern extends beyond customer lifetime value to use cases such as churn reduction, cross-sell optimization, and service issue deflection, without redesigning the underlying architecture. Performance comes from keeping computation in Teradata Vantage; auditability comes from end-to-end traces of signals, decisions, and actions; and delivery speed comes from reusable prompts, tools, and node templates assembled in AgentBuilder.

Ready to turn signals into outcomes?

Building Autonomous Customer Intelligence: A Developer’s Guide to Teradata’s Customer Intelligence… was originally published in Teradata on Medium, where people are continuing the conversation by highlighting and responding to this story.

If you build data pipelines or analytic Python scripts, like dbt models, in Visual Studio Code (VS Code), you know the pain of context-switching just to sanity-check a column list or scan for NULLs. Traditional SQL clients are great, but bouncing between these database clients and VS Code can be distracting and break your flow when your focus is the code you’re writing on VS Code.

Teradata’s Model Context Protocol (MCP) server helps you by allowing GitHub Copilot Chat to talk to your data directly, providing a handy assistant for drafting analytics scripts.

Teradata MCP server is an open and extensible backend server that acts as a bridge between large language models (LLMs) and your Teradata environment, allowing you to query data, explore metadata, and even validate logic just by asking questions in plain English.

You stay in VS Code, GitHub Copilot routes data-related requests to the MCP server, and results come back in the chat.

With this setup, GitHub Copilot can:

• Interpret your natural language questions
• Translate them into SQL queries behind the scenes
• Connect to your Teradata Vantage® instance
• Retrieve structured answers directly in your Copilot chat window

In this article, I’ll walk you through:

• How to set up your development environment to take advantage of Teradata MCP Server
• How to set up your own MCP server to work with GitHub Copilot Chat in VS Code
• How to query your Teradata database as if you’re having a conversation, simplifying chores like discovering tables, validating filters, and validating data quality in VS Code

Let’s begin the setup.

Requirements

• A free Teradata VantageCloud environment. Get one in just a few minutes via ClearScape Analytics® Experience.
• Visual Studio Code with the Copilot Chat and MCP-Client extensions. The download is available at https://code.visualstudio.com/.
• A Teradata MCP server. An open-source community edition is available in Teradata’s GitHub organization; later we’ll cover the details for cloning this repository and setting up the server.

Preparing the development environment

Log into ClearScape Analytics® Experience

• Sign up for a free account if you haven’t already, or log in.
• In the console, select “create new environment.” Take note of your host and password and the username and database, which will also be needed to set up your server later, default to demo_user in ClearScape Analytics® Experience.

Install uv

We utilize the uv package manager to run the Teradata MCP server in an isolated Python environment to avoid package conflicts and ease the setup.

• Install uv by following the steps at https://docs.astral.sh/uv/getting-started/installation/
• Verify if uv is properly installed, open your terminal, and run: ```uv –v```

This will display the installed version of uv. If you see any error, make sure you have followed the installation instructions and restart the console.

Setting up your own Teradata MCP server to work with GitHub Copilot in Visual Studio Code

Clone the Teradata MCP Server

git clone https://github.com/Teradata/teradata-mcp-server.git

Set environment variables

Create a .env file with the following structure:

DATABASE_URI= teradata://username:password@host:1025/databasename
LOGMECH=TD2 #TD2 or LDAP
MCP_TRANSPORT=stdio
PROFILE = dba

We’ll use the stdio transport method in this setup, though other methods are also available. Check the relevant documentation in the repository for details.

• Replace username, password, host, and database name with your own Teradata Vantage® credentials.
• The DATABASE_URI tells the server where to point your queries.
• Given the tasks we’re performing, we need a profile that enables the required tools. Specifically, set PROFILE=dba to access the required toolset.

Start the MCP Server

From your project directory (i.e., the folder where you cloned the teradata-mcp-server), test starting the MCP server using the following command.

uv run teradata-mcp-server

This boots up the MCP server to verify that everything is working as expected. If everything is in order, you can interrupt this run by pressing Ctrl + C.

Connecting the MCP server to GitHub Copilot in VS Code

Now let’s link this server to your GitHub Copilot:

1. Open VS Code
2. Press Ctrl + Shift + P to open the Command Palette
3. Select MCP: Add Server
4. Choose stdio as the transport type
5. Fill in the dialog as follows:
6. Command: “uv”
7. ID: For example, “teradata-mcp-server”
8. Then confirm and save now

An mcp.json file will be created automatically. Complete the required arguments as shown below:

{
"mcp": {
"servers": {
"teradatastdio": {
"type": "stdio",
"command": "uv",
"args": [
" - directory",
"<Full Path>/teradata-mcp-server",
"run",
"teradata-mcp-server"
],
}
}
}
}

Make sure to replace <full path> with the actual location of the teradata-mcp-server directory if it didn’t load itself.

Launch the MCP Server in VS Code

Once configured, start the server from within VS Code if it didn’t start itself:

• Friendly controls to start, restart, and stop the server overlay on top of the mcp.json file for convenient operation

Chat with your data

To interact with your Teradata database in natural language, you’ll need to use Copilot in Agent Mode, which allows GitHub Copilot Chat to talk directly to the MCP server.

Here’s how to do it.

Open GitHub Copilot Chat in VS Code

• In your sidebar, click on the GitHub Copilot Chat icon.
• If you don’t see it, open the Command Palette (Ctrl + Shift + P) and search for “GitHub Copilot: Open Chat View”

Switch to Agent Mode

• Go to the Copilot Chat panel in VS Studio
• Ensure it’s set to Agent Mode (not Chat Mode). If you don’t see this, go to command palette to enter Copilot: Toggle Agent Mode.

Once in Agent Mode, Copilot will be ready to route your questions through the MCP server to your Teradata backend and return results right inside your chat window.

Note on data: By default, our walkthrough defines demo_user as the default database. This database is empty in a new ClearScape Analytics® environment, you should load sample data first or update the database/table names in the examples to match tables that exist in your environment. This ensures you can explore and query your data.

Try prompts like:

• “Show me the first 5 rows from demo_user.dim_customers”
• “What tables exist in the demo_user schema?”
• “Give me the total sales by region from demo_user.sales_fact”
• “Which columns are available in the demo_user.orders table?”

Conclusion

By combining Teradata’s MCP Server with GitHub Copilot Chat in Visual Studio Code, we unlock a powerful way to make data feel more conversational, accessible, and integrated into the daily developer workflow.

If you’re someone who works with Teradata and builds in VS Code, I highly recommend giving this workflow a try. Running the queries and getting results in the chat might boost your productivity.

Got questions or want to share your own use case? Feel free to reach out or leave a comment.

About Joshitha Recharla

Joshitha Recharla is a developer advocate intern at Teradata and a graduate student in data science at SUNY Buffalo. She enjoys breaking down complex AI and analytics workflows into hands-on, developer-friendly tutorials and demos. Through her internship, she has explored how tools like MCP can make data more accessible and useful where developers work.

Chat with your data in Visual Studio Code through an MCP server was originally published in Teradata on Medium, where people are continuing the conversation by highlighting and responding to this story.

Operationalizing AI in a secure, on-premises environment comes with its own set of challenges, especially when the goal is to build production-ready applications that handle sensitive, high-volume, or unstructured data.

For a data scientist, that might mean testing large language models against internal documents. For a Machine Learning engineer, it could involve deploying and scaling models efficiently across GPU resources. A data engineer may be focused on integrating structured and unstructured data into unified pipelines, while an AI architect is looking for a system that supports end-to-end control, compliance, and performance at scale.

Teradata and NVIDIA enable AI factories that support all these needs with integrated tools for model development, governance, inference, and vector storage, all working together within your trusted infrastructure.

For a more detailed overview of how Teradata enables AI factories with NVIDIA, ​​explore this article.

In this article, we walk through how it works, from accessing ​Teradata ​AI Workbench and deploying a foundation model, to running GPU-accelerated inference and building a RAG pipeline using a PDF document.

How Teradata ​Enables ​AI Factories

Automating the full claims lifecycle from document extraction to settlement without human intervention. Monitoring conversations in real time to detect compliance risks before they escalate. Enhancing Anti-Money Laundering detection by bringing together structured records and unstructured sources like social media.

These are just a few of the practical, high-impact solutions developers can build with Teradata.

With integrated vector storage, GPU-accelerated inference, ClearScape Analytics®, and a full-featured AI Workbench, Teradata turns these complex workloads into secure, scalable, and executable pipelines entirely within your own infrastructure.

Let’s take a look at how you can leverage Teradata and NVIDIA for your AI factory.

Accessing the ​Teradata​ ​​AI Workbench

Your journey begins at the ​​Teradata ​​AI Workbench landing page, your central hub for everything AI. From here, you can launch notebooks, utilize ModelOps, manage users, and access support if needed, all from a single interface.

Exploring ModelOps for advanced AI management

Inside the Workbench, ModelOps provides a complete environment for managing your AI models, including access to NVIDIA NIM microservices and a collection of over 80+ pre-trained Large Language Models (LLMs), all ready to be deployed on your GPUs using NIM​.​

Selecting a model

Selecting a model is as simple as a click. Choose any ​​NIM​​, and a model card will open with details such as model evaluation, benchmark performance, license information, and resource profile.

One-click model deployment

After reviewing a model, you can deploy it with just one click. Once deployed, you receive an endpoint and a code snippet, perfect for integrating the model into your Generative AI applications, including Retrieval-Augmented Generation (RAG) workflows with Teradata Enterprise Vector Store.

Running inferences and building applications

With your model deployed and the endpoint ready, you can immediately start running inferences against your data. This enables you to quickly build applications for demonstration, experimentation, or even production use cases.

A practical use case: PDF Vector Store with RAG

One of the standout capabilities is its ability to transform unstructured documents into actionable insights using RAG.

Teradata AI Microservices with NVIDIA enables access to GPU-accelerated tools for processing PDFs, extracting text, images, tables, and charts using OCR, object detection, and table parsing. These documents are then enriched using NVIDIA NIM to generate high-dimensional vector embeddings via contextual LLMs.

Finally, the embeddings are indexed in Teradata’s Enterprise Vector Store, enabling fast, intelligent search across the data. This pipeline makes it easy to build RAG applications that can analyze, summarize, and surface relevant insights from unstructured documents — quickly and securely.

Code example: building a Vector Store with an NVIDIA model

Let’s walk through how to create a vector store and ask contextual questions using a PDF document. In this example, we’re using a sample file named data_access_policy.pdf to demonstrate the steps. You can replace it with your own document as needed.

1. Install and import required modules

Install the teradatagenai module, a Teradata package for Generative AI and import the required classes.

!pip install teradatagenai
from teradatagenai import VSManager, VectorStore, VSPattern, VSApi
import os

2. Initialize the Vector Store

Create an instance of the vector store named “vs_chatbot”

chatbot = VectorStore('vs_chatbot')

You can also check the system health to know if your system is running fine or not with “VSManager.health()”.

3. Load the document and define the embedding model

Load a sample PDF and specify the NVIDIA embedding model (nv-embedqa-mistral-7b-v2).

files = [os.path.join(os.getcwd(), "data_access_policy.pdf")]
embeddings_model = 'nvidia/nv-embedqa-mistral-7b-v2'

nv-embedqa-mistral-7b-v2 is a multilingual text question-answering retrieval model from NVIDIA.

4. Create the Vector Store

Generate the vector embeddings for the document and store them using Teradata’s Enterprise Vector Store.

chatbot.create(embeddings_model=embeddings_model,
search_algorithm= 'VECTORDISTANCE',
top_k= 10,
object_names= ['data_access_policy'],
data_columns= ['chunks'],
vector_column= 'VectorIndex',
chunk_size= 500,
optimized_chunking=False,
document_files=files)

5. Check Vector Store Status

Confirm if the vector store is ready for querying.

chatbot.status()

6. Ask a contextual question

You can query the vector store with a business-specific question using ask method. The vector store will use its similarity search to find the most relevant information and provide a detailed response.

question = 'What are the levels of access to patient data allowed in our organization?'
prompt = 'List the levels of access and briefly describe them.'
response = chatbot.ask(question=question, prompt=prompt)
print(response)

This response was generated directly from the uploaded PDF using the ask() function in Teradata AI Factory. It shows how unstructured documents can be converted into actionable insights accurately, securely, and instantly.

Conclusion

Teradata and NVIDIA provide everything needed to build, deploy, and manage AI workloads entirely on-premises by combining model development, GPU-powered inference, vector management, and workflow automation into a single integrated environment.

AI factories leveraging Teradata and NVIDIA equip data scientists, machine learning engineers, data engineers, and AI architects with the tools to experiment, scale, and operationalize AI, all while maintaining full control over performance, compliance, and data security.

To learn more about AI factories leveraging Teradata and NVIDIA, explore here.

Teradata Enables AI Factories with NVIDIA: On-premises, secure, and predictable AI development was originally published in Teradata on Medium, where people are continuing the conversation by highlighting and responding to this story.

Agentic AI refers to artificial intelligence systems that can operate autonomously, make decisions, and take actions to achieve specific goals with minimal human intervention. These systems exhibit characteristics like reasoning, planning, adaptability, and goal-directed behavior.

Building agentic AI systems in the enterprise often means manually integrating components and frameworks for connecting to large language model providers, managing prompts, executing tools, handling memory and context, and ensuring agents have access to relevant data and business domain knowledge. For AI engineering, data science, and data engineering teams, this creates considerable overhead in infrastructure setup before they can even begin experimenting or building agentic solutions for their customers and organizations.

Teradata AgentBuilder simplifies this process by offering a unified developer experience that connects autonomous agents to trusted data, domain expertise, and scalable tools. Everything is integrated and deployed alongside Teradata. Teradata removes the infrastructure burden and provides an enterprise-grade agentic data stack out of the box.

Teradata AgentBuilder is a set of capabilities that enables enterprises to build and manage autonomous AI agents with trusted data, domain expertise, and hybrid deployment flexibility.

These capabilities include:

• UI: A UI interface to build agents and develop multi-agent workflows. Current choices include open-source tools such as Flowise, CrewAI, LangGraph as well as partner tools from CSPs, and NVIDIA.
• Context intelligence combines Teradata IP such as expert prompts, contextual understanding, and the right tools with open-and-connected LLM APIs.
• Teradata MCP Server and tools, which enables agents to leverage tools for descriptive, predictive, and prescriptive analytics. The toolset will comprise Basic tools, DBA Tools, EFS (Enterprise Feature Store), Quality Tools, vector store, RAG, metadata, SQL tools, and a few select ClearScape Analytics® tools.
• Pre-built Agents — Teradata developed agents: Teradata SQL agent, Teradata data science agent and Teradata monitoring agent.

All these components are designed to work together, giving teams a robust foundation for building intelligent multi-agent systems.

In this post, we’ll walk through a credit risk profiling use-case powered by a multi-agent system, built on top of Teradata AgentBuilder. While the demo focuses on core MCP tools and agent workflows, Teradata also provides industry data models that can be embedded to enrich agent context. These models offer a powerful way to infuse agents with business logic and domain expertise, making them more effective in solving real-world problems.

A credit risk profiling multi-agent system

We built a multi-agent AI system to analyze credit risk data using Teradata AgentBuilder. The data is stored and processed in Teradata Vantage. Based on historical records, we deployed a credit risk assessment model using ClearScape Analytics. This agentic system can query and interpret data from the database, act as a data analyst, score applicants against the model to assess their risk profile and explain the logic behind the model.

This system was implemented using Flowise integration within AgentBuilder, and while this demo highlights Flowise, additional integrations are already supported, and more are on the way.

The architecture of the system is the following:

With the following nodes:

• Start node:
  Defines how the workflow is initiated, in this case through a chat interface (form inputs are also available).
• Condition agent node:
  Routes the flow to purpose specific agents according to the user’s intent as inferred from the user’s prompt.
• Purpose specific agent nodes:
  Execute the actual task needed to respond to the user’s prompt. This can be either providing information regarding what data is available in the relevant database, performing summaries and aggregations of data, acting as a data analyst, scoring data against the deployed model or explaining the model itself.

The risk assessment model is a Generalized Linear Model created and deployed through Teradata ClearScape Analytics. The specific steps followed to create the model can be explored in this notebook (also available ready to execute in ClearScape Analytics Experience); they are not covered in detail in this blog.

The start node

This node initializes the flow by capturing the user input, as a chat prompt or as a form submission.

The flow state, or variables used by the flow are defined in the start node.

Agent nodes

The flow consists of five agent nodes, one of these agent nodes is a router node, which routes the flow to the specific purpose agents according to the user intent. The other four are purpose-specific agents that respond to the user with a clearly defined scope.

Common configurations to all agent nodes

Each node is individually configured through a low-code user interface.
All agent nodes require access to large language models (LLMs), which can be integrated via cloud service providers or on-premise deployments. Additionally, the four purpose-specific agents also require access to Teradata MCP server.

Teradata AgentBuilder seamlessly incorporates these components, making them straightforward to configure within each corresponding node.

LLM configuration

In this case, access to LLMs is provided through a cloud service provider. The specific models available, along with the required credentials and base URL, depend on your particular deployment of Teradata and AgentBuilder.

MCP configuration

Access to the Teradata MCP server is configured through the tools panel. As with LLM integration, the connection URL and credentials depend on your specific deployment of Teradata and AgentBuilder.

After configuring the MCP server, all related tools are available for selection.

Question evaluation agent

A condition agent node routes the flow according to the user intent, the most important configurations in this node are the general instructions which detail the logical flow and rationale of each of the individual routes, and the scenario list which creates each of the separate branches of the flow (four in total, one shown in the graph below). The input, in this example, is the {{question}} variable, this is a global variable that contains the initial prompt of the user to the chatbot agent and that can be retrieved from any of the nodes in the flow.

This agent evaluates the user’s query against the following four scenarios:

• User is asking about tables, columns or types of columns → Route to the data exploration agent
• User is asking about summarizing, aggregating or otherwise calculating on the data of a given table → Route to the data aggregation agent
• User is asking for assessing the risk profile of a specific record → Route to the credit profiling agent
• User is asking for an analysis of the assessment model → Route to the model analysis agent

The agent is instructed to:

• Analyze the input: Determine the user’s intent based on phrasing and keywords.
• Match to a scenario: Compare the input against the list of scenarios.
• Route accordingly: Return the selected scenario in JSON format, which triggers the corresponding agent node.

Purpose-specific agents

The primary configuration for each agent is its corresponding system prompt. It is important that every purpose-specific agent has a clearly defined scope of action. This allows designing system prompts that deliver precise and relevant instructions tailored to the agent’s task. One agent handles general data exploration, another focuses on summarization and aggregation, a third performs data scoring, and a fourth interprets the credit risk model.

Data exploration and data summarization agents

These are the simplest agents, they answer questions regarding the data present in our risk credit profiling database, and perform summarizations, acting like a data analyst for this specific dataset.

These agents respond to queries like the one shown below:

Credit profiling agent

The credit profiling agent is the core of the project. It retrieves the data from a given credit application and based on that data, assesses the credit profile of the applicant. This assessment is guided by the scoring logic of the ClearScape Analytics credit profiling model, which is deployed directly within the Teradata Vantage database.

The details of this process are detailed in the corresponding system prompt for the agent:

This prompt utilizes ClearScape Analytics experience scoring capabilities to score the requested data upon a user’s request.

What determines a strong or weak credit profile within the context of the currently deployed model? The final agent in the system analyzes the model’s parameters and provides responses to potential queries from business users regarding the workings of the model.

Model analysis agent

This agent retrieves the parameters stored in the table where the credit profiling model resides and provides insights into how specific features influence the resulting credit profile.

Conclusion

With Teradata AgentBuilder, teams can move beyond infrastructure setup and start building intelligent multi-agent systems that are deeply integrated with enterprise data and domain knowledge. By combining open-source agentic frameworks, scalable tooling, and trusted data access through Vantage, AgentBuilder provides a streamlined path from experimentation to production. Whether you’re modeling credit risk, optimizing supply chains, or building customer-facing assistants, your agentic data stack starts here, with the flexibility, performance, and reliability that enterprise AI demands.

Ready to start building?

Agentic AI Stack with Teradata AgentBuilder was originally published in Teradata on Medium, where people are continuing the conversation by highlighting and responding to this story.