How to Use the Cooper Hewitt MCP in LangChain

Q: How does LangChain handle the response format of Cooper Hewitt tools?

Your agent automatically parses the JSON output from specformats and getobjectinfo using standard LangChain tool call parsers. It treats the museum's design metadata as structured dictionary inputs for your next chain link.

Q: Can I trace Cooper Hewitt search queries with LangChain and LangSmith?

Yes, every tool execution like searchcollection or getobjectimages shows up as a distinct step in your LangSmith dashboard. You can inspect the exact query parameters, raw JSON responses, and token counts for each museum search.

Q: How do I configure a multi-server setup with Cooper Hewitt and LangChain?

You pass the server's endpoint to MultiServerMCPClient along with your other servers. This lets your agent query museum objects via getrandomobject while simultaneously calling tools from other services in a single agentic loop.

Q: What happens if a Cooper Hewitt tool call fails inside a chain?

The server includes a testerror tool specifically to let you test your LangChain error-handling and retry wrappers. If the museum API drops a request, your chain can catch the exception and fall back gracefully.

Feed Cooper Hewitt design history directly into your LangChain multi-step reasoning pipelines and tool-use chains.

See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

MCP Servers - Free for Subscribers

Connect Cooper Hewitt MCP to LangChain

Create your Vinkius account to connect Cooper Hewitt to LangChain and route execution through our secure gateway. The platform manages server hosting, runtime updates, and security layers. Configuration requires no manual server provisioning.

GDPR Free for Subscribers

Setup Cooper Hewitt with LangChain

Ask AI about this MCP

ChatGPT

Claude

Perplexity

Chain Cooper Hewitt Color Data into Multi-Step LangChain Runs

By exposing design data tools like `get_object_colors`, this MCP Server lets you fetch actual museum palettes. Your LangChain agent grabs hex codes from an object, then passes those exact color values directly to a downstream vector search or a palette generation chain in one execution. It's easy to track the entire flow inside LangSmith to monitor latency and check exactly what payload the museum API returned. You see the raw JSON colors move from one tool run to the next step, cutting out the guesswork.

Deep-Dive Exhibition Research with Self-Directing Agents

Querying physical galleries becomes straightforward when this MCP Server runs `list_exhibitions` and `get_exhibition_objects` to map out design history. The agent determines which exhibition to examine based on intermediate search hits, then pulls the exact objects displayed in those physical rooms. You build reasoning loops where the agent decides whether to pull participant details using `get_object_participants` or stop the chain. This prevents your pipeline from wasting tokens on irrelevant museum records by making smart decisions at each turn.

Faceted Collection Searches Fed Directly to Vector Stores

Accessing the museum's database with `search_objects_faceted` allows this MCP Server to retrieve structured metadata categorized by physical location or design era. Your LangChain agent parses these facets to build filtered search runs and conditional chains without manual formatting. The agent feeds these structured museum records directly into your document loaders. You get precise design history metadata loaded into your chains without dealing with messy API pagination or custom parsing code.

Setup guide

Set up Cooper Hewitt MCP in LangChain

Prerequisites

Python 3.10+ installed
langchain-mcp-adapters + langgraph packages
Active Vinkius subscription with a valid endpoint token

1

Install dependencies
Run pip install langchain-mcp-adapters langgraph langchain-openai. The MCP adapters package converts MCP tools into native LangChain BaseTool objects.
2

Connect via HTTP transport
Use MultiServerMCPClient with "transport": "http" pointing to your Vinkius endpoint. Replace [YOUR_TOKEN_HERE] with your token from cloud.vinkius.com.
3

Create a ReAct agent
Pass the discovered tools to create_react_agent() from LangGraph. The agent automatically routes Cooper Hewitt tool calls through the MCP protocol.
4

Run with any LLM
Swap ChatOpenAI for ChatAnthropic, ChatGoogleGenerativeAI, or any LangChain-compatible model. The MCP tools work identically across all providers.

agent.py

from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI

async with MultiServerMCPClient({
    "cooper-hewitt-mcp": {
        "transport": "http",
        "url": "https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp",
    }
}) as client:
    tools = client.get_tools()

    agent = create_react_agent(
        ChatOpenAI(model="gpt-4o"),
        tools,
    )
    result = await agent.ainvoke({
        "messages": "List recent Cooper Hewitt transactions"
    })
    print(result["messages"][-1].content)

Get your connection token →

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Cooper Hewitt. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.

Why Choose Vinkius

Vinkius connects your tools to AI with real-time monitoring and automatic cost savings — all from one dashboard.

Connect Cooper Hewitt now

Real-time monitoring

Live

visibility into every interaction

Connect your favorite tools to your AI and see exactly what's happening — every request, every response, in real time.

Built-in savings

60%

lower AI costs

Vinkius compresses data between your apps and your AI automatically. Lower bills every month — no configuration required.

Single dashboard

One

place for every integration

Every tool your AI connects to, managed from a single screen. One account, complete control.

Common questions about Cooper Hewitt MCP in LangChain

Your agent automatically parses the JSON output from `spec_formats` and `get_object_info` using standard LangChain tool call parsers. It treats the museum's design metadata as structured dictionary inputs for your next chain link.

Yes, every tool execution like `search_collection` or `get_object_images` shows up as a distinct step in your LangSmith dashboard. You can inspect the exact query parameters, raw JSON responses, and token counts for each museum search.

You pass the server's endpoint to `MultiServerMCPClient` along with your other servers. This lets your agent query museum objects via `get_random_object` while simultaneously calling tools from other services in a single agentic loop.

The server includes a `test_error` tool specifically to let you test your LangChain error-handling and retry wrappers. If the museum API drops a request, your chain can catch the exception and fall back gracefully.

All queries for exhibition objects and design colors run inside a secure V8 isolate sandbox that does not store your search strings. The server only handles read-only museum metadata from the Smithsonian, keeping your proprietary design prompts completely private.

Use it with your favorite AI tools

Connect this server to Cursor, Claude, VS Code, and more.

OpenAI Agents SDK sdk-python

Google ADK sdk-python

Pydantic AI sdk-python

Vercel AI SDK sdk-typescript