PoC: `InferenceClient` is also a `MCPClient` #2986

julien-c · 2025-04-08T11:28:05Z

EDIT from @Wauplin :

I took over the work from @julien-c to integrate it in huggingface_hub more officially:

now exported as huggingface_hub.MCPClient. Class is flagged as "experimental" meaning we can introduce breaking changes without prior notice.
accept "auto" provider
can be used with async context (e.g. async with MCPClient(...) as client:) => takes care of cleaning-up
made add_mcp_server as close to JS client as possible. Still todo: handle SSE and Streaming servers (in later PR)
if tool already defined by another MCP server, skip it (avoid conflicts)
renamed process_query to process_single_turn_with_tools => now takes a list of messages as input
- WARNING: input messages is mutated in-place!
made process_single_turn_with_tools an async generator, keeping logic close to JS SDK
made InferenceClient.chat_completion accept (messages: List[Union[Dict, ChatCompletionInputMessage]],) (in practice already the case, just an additional type hint now)

That's about it. See comment below for example + result. #2986 (comment)

End of @Wauplin addition.

Required reading

https://modelcontextprotocol.io/quickstart/client

TL;DR: MCP is a standard API to expose sets of Tools that can be hooked to LLMs

Summary of how to use this

EDIT: see #2986 (comment)

Open questions

Should we implement this in (Async)InferenceClient directly? Or on a distinct class, like here?

Where to find the MCP Server used here as an example

Note that you can replace it with any MCP Server, from this doc for instance: https://modelcontextprotocol.io/examples

https://gist.github.com/julien-c/0500ba922e1b38f2dc30447fb81f7dc6

EDIT: and https://gist.github.com/Wauplin/b6e5f1a39db843eedfa00738e4998589

Script output

Generation from LLM with tools

3D Model Generation from Text

Here are some of the best apps that can generate 3D models from text:

Shap-E
- Link: huggingface.co/spaces/hysts/Shap-E
- Description: This app supports both text-to-3D and image-to-3D generation.
Hunyuan3D-1
- Link: huggingface.co/spaces/tencent/Hunyuan3D-1
- Description: Another robust tool for generating 3D models from text and images.
LGM
- Link: huggingface.co/spaces/ashawkey/LGM
- Description: Generates 3D content from images or text.
3D-Adapter
- Link: huggingface.co/spaces/Lakonik/3D-Adapter
- Description: Generates 3D models from text descriptions.
Fictiverse-Voxel_XL_Lora
- Link: huggingface.co/spaces/mygyasir/Fictiverse-Voxel_XL_Lora
- Description: Generates 3D models from text prompts.

Best Paper on Transformers

One of the most influential and highly cited papers on transformers is:

Title: "Attention Is All You Need"
Authors: Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Łukasz Kaiser, Illia Polosukhin
Link: huggingface.co/papers/1706.03762
Description: This paper introduced the Transformer architecture, which has become a cornerstone in natural language processing and many other areas of deep learning.

If you are looking for more recent advancements, here are a few other notable papers:

Title: "RoFormer: Enhanced Transformer with Rotary Position Embedding"
Link: huggingface.co/papers/2104.09864
Description: This paper introduces RoFormer, which improves the Transformer by using rotary position embeddings.
Title: "Performer: Generalized Attention with Gaussian Kernels for Sequence Modeling"
Link: huggingface.co/papers/2009.14794
Description: This paper presents Performer, a more efficient and scalable version of the Transformer.
Title: "Longformer: The Long-Document Transformer"
Link: huggingface.co/papers/2004.05150
Description: This paper introduces Longformer, which extends the Transformer to handle very long documents.

These resources should provide you with a solid foundation for both generating 3D models from text and understanding the latest advancements in transformer models.

HuggingFaceDocBuilderDev · 2025-04-08T11:32:21Z

The docs for this PR live here. All of your documentation changes will be reflected on that endpoint. The docs are available until 30 days after the last update.

…ferenceClient

mishig25 · 2025-04-08T14:03:40Z

mcp_client.py

+        self.exit_stack = AsyncExitStack()
+        self.available_tools: List[ChatCompletionInputTool] = []
+
+    async def add_mcp_server(self, command: str, args: List[str]):


why not name this method connect_to_server ?
we can't add multiple mcp servers to single instance of client, can we?

i mean we would need to store a map of sessions, but there's nothing preventing us from doing it, conceptually

let me know if the following question is out of scope.
Question: how would I connect to multiple MCP servers? Would it look like option 1 or option 2?

Option 1

client1 = MCPClient() client1.add_mcp_server() client2 = MCPClient() client2.add_mcp_server()

or

Option 2

client = MCPClient() client.add_mcp_server(server1) client.add_mcp_server(server2)

?

another design question: class MCPClient(AsyncInferenceClient) vs class AsyncInferenceClient(...args, mcp_clients: MCPClient[])

Sorry to chime in unannounced, but from a very removed external user standpoint, I find this all very confusing - I just don't think what you coded should be called MCPClient 😄

When I came to this PR I was fully expecting MCPClient to be passed as parameter to InferenceClient, though I hear @Wauplin above, so why not a wrapper. But the end result is really more of an InferenceClientWithEmbeddedMCP to me, not an MCPClient.

That being said, it's just about semantics, but I'm kind of a semantics extremist, sorry about that (and feel free to completely disregard this message, as is very likely XD)

I was fully expecting MCPClient to be passed as parameter to InferenceClient

What do you mean as parameter? Do you have an example signature?

second option of #2986 (comment)

ah yes, sure, we can probably add this I guess

ah actually with the async/await stuff i'm not so sure.

mcp_client.py

Co-authored-by: Mishig <[email protected]>

@mishig25

cc @mishig25

… AsyncInferenceClient" This reverts commit 2c7329c.

@Wauplin

cc @Wauplin

grll

few comments out of my head, SSE supports would not be so hard to add and could really be a nice addition

grll · 2025-04-16T16:26:43Z

mcp_client.py

+        self.exit_stack = AsyncExitStack()
+        self.available_tools: List[ChatCompletionInputTool] = []
+
+    async def add_mcp_server(self, command: str, args: List[str], env: Dict[str, str]):


you would need to lighten a bit the requirements on your args if you want to make it work with SSE or the intent is just to support STDIO ? I see the rest seems to focus on stdio so maybe it's by design

for now, just Stdio, but in the future Streaming HTTP from what i've understood should be the way to go?

yes this is the new spec, but it is backward compatible and at the level you are working with in this PR I wouldnt expect much to change, probably the internals of the client will change but the client interface would remain the same. Which means if today you do something like add_mcp_server(StdioParameters | dict) dict being the arguments of the sse_client from the python sdk you could already support all the SSE servers + potentially future Streaming HTTP server with minor adjustments at most

grll · 2025-04-16T16:28:27Z

mcp_client.py

+                "function": {
+                    "name": tool.name,
+                    "description": tool.description,
+                    "parameters": tool.inputSchema,


just a note that I have seen some MCP servers with jsonref in their description which sometimes confuses the model. In mcpadapt I had to resolve the jsonref before passing it to the model, might be minor for now

confused or sometime plain unsupported by the model sdk like google genai...

Interesting, does the spec mention anything about whether jsonref is allowed or not?

I don't think the spec mention it however, it gets auto generated if you use pydantic models by the official mcp python sdk using the fastMCP syntax. I had the case for one of my mcp server I use to test things: https://github.com/grll/pubmedmcp

mcp_client.py

julien-c · 2025-04-17T07:49:41Z

Thanks for the review @grll!

grll · 2025-04-18T06:50:56Z

FYI on what I was saying about sse_client being easy to add:

https://github.com/modelcontextprotocol/python-sdk/pull/416/files#diff-3223f09c8047aee59a2209f564b9bbf0258d4dabe30be98478b9cc8c599144aeR23-R30

this is a current proposal for a streaming HTTP client while not compatible and not officially approved or commented on you see that it takes the same arguments as before and even fallback to the SSE client if detected and yield the same as before (a read and write stream). Same as the stdio client.

julien-c · 2025-04-18T07:54:41Z

@grll indeed, thanks. I think i'll merge this PR almost as-is, but we'd welcome further PRs to add SSE/HTTP and other stuff!

mcp_client.py

setup.py

mcp_client.py

## Required reading https://modelcontextprotocol.io/quickstart/client TL;DR: MCP is a standard API to expose sets of Tools that can be hooked to LLMs ## Summary of how to use this You can either use McpClient, or you can run an example Agent directly: # Tiny Agent We now have a tiny Agent (a while loop, really) in this PR, built on top of the MCP Client. You can run it like this: ```bash cd packages/mcp-client pnpm run agent ``` # `McpClient` i.e. the underlying class ```ts const client = new McpClient({ provider: "together", model: "Qwen/Qwen2.5-72B-Instruct", apiKey: process.env.HF_TOKEN, }); await client.addMcpServer({ // Filesystem "official" mcp-server with access to your Desktop command: "npx", args: ["-y", "@modelcontextprotocol/server-filesystem", join(homedir(), "Desktop")], }); ``` ## Variant where we call a custom, local MCP server ```ts await client.addMcpServer( "node", ["--disable-warning=ExperimentalWarning", join(homedir(), "Desktop/hf-mcp/index.ts")], { HF_TOKEN: process.env.HF_TOKEN, } ); const response = await client.processQuery(` find an app that generates 3D models from text, and also get the best paper about transformers `); ``` #### Where to find the MCP Server used here as an example https://gist.github.com/julien-c/0500ba922e1b38f2dc30447fb81f7dc6 (Note that you can replace it with any MCP Server, from this doc for instance: https://modelcontextprotocol.io/examples) ## Python version Python version will be implemented in `huggingface_hub` in this PR: huggingface/huggingface_hub#2986 Contributions are welcome! --------- Co-authored-by: Eliott C. <[email protected]> Co-authored-by: SBrandeis <[email protected]> Co-authored-by: Simon Brandeis <[email protected]>

…nto mcp-client

Wauplin · 2025-05-13T18:18:50Z

I just pushed changes to clean this PR. See PR description for list of changes #2986 (comment). It should now be very close to JS SDK (no SSE / Streaming-HTTP server support though it can be easily added later).

Example:

import os

from huggingface_hub import ChatCompletionInputMessage, ChatCompletionStreamOutput, MCPClient

async def main():
    async with MCPClient(
        provider="nebius",
        model="Qwen/Qwen2.5-72B-Instruct",
        api_key=os.environ["HF_TOKEN"],
    ) as client:
        await client.add_mcp_server(
            command="python",
            args=["hf_mcp.py"],  # https://gist.github.com/Wauplin/b6e5f1a39db843eedfa00738e4998589
            env={"HF_TOKEN": os.environ["HF_TOKEN"]},
        )

        messages = [
            {
                "role": "user",
                "content": "what are the most recently updated models from nvidia? Explain your reasoning.",
            }
        ]

        async for chunk in client.process_single_turn_with_tools(messages):
            # Log messages
            if isinstance(chunk, ChatCompletionStreamOutput):
                delta = chunk.choices[0].delta
                if delta.content:
                    print(delta.content, end="")

            # Or tool calls
            elif isinstance(chunk, ChatCompletionInputMessage):
                print(
                    f"\nCalled tool '{chunk.name}'. Result: '{chunk.content if len(chunk.content) < 100 else chunk.content[:100] + '...'}'"
                )


if __name__ == "__main__":
    import asyncio

    asyncio.run(main())

Producing:

/home/wauplin/projects/huggingface_hub/src/huggingface_hub/utils/_experimental.py:60: UserWarning: 'MCPClient.__init__' is experimental and might be subject to breaking changes in the future without prior notice. You can disable this warning by setting `HF_HUB_DISABLE_EXPERIMENTAL_WARNING=1` as environment variable.
  warnings.warn(
[05/13/25 20:15:17] INFO     Processing request of type ListToolsRequest                                                                            server.py:545
To find the most recently updated models from NVIDIA, we can use the `list_models` function from the Hugging Face Hub API. Specifically, we will filter by the author (`nvidia`) and sort the results by the `last_modified` date in descending order. This will give us the models that were most recently updated.

Here is the reasoning:
1. **Author Filter**: We filter by the author `nvidia` to ensure we only get models from NVIDIA.
2. **Sorting by Last Modified**: We sort the models by the `last_modified` date in descending order to get the most recently updated models at the top of the list.

Let's make the function call to get the most recently updated models from NVIDIA:

[05/13/25 20:15:22] INFO     Processing request of type CallToolRequest                                                                             server.py:545

Called tool 'list_models'. Result: '[ModelInfo(id='nvidia/Llama-3.3-70B-Instruct-FP8', author=None, sha=None, created_at=datetime.dateti...'

This should now be ready for review :)

hanouticelina

🔥
I tested the PR too, it works as expected!
agree to add SSE / Streaming server support in a following PR 💯

hanouticelina · 2025-05-15T16:53:45Z

src/huggingface_hub/inference/_mcp/mcp_client.py

+
+        # List available tools
+        response = await session.list_tools()
+        logger.debug("Connected to server with tools:", [tool.name for tool in response.tools])


I'm getting a silent error TypeError: not all arguments converted during string formatting because the 2nd positional arg is treated as a %s placeholder

Suggested change

logger.debug("Connected to server with tools:", [tool.name for tool in response.tools])

logger.debug("Connected to server with tools: %s", [tool.name for tool in response.tools])

hanouticelina · 2025-05-15T16:55:42Z

src/huggingface_hub/inference/_mcp/mcp_client.py

+            tools = [*exit_loop_tools, *self.available_tools]
+
+        # Create the streaming request
+        async with self.client:


is the async with mandatory here? we already open self.client in __aenter__

See my comment above: I proposed keeping the with block here and removing the self.client from the __aenter__ above.
The reason is that self.client stores an HTTP response object each time it make a request: so better cleaning this resource after the request/response has been handled (here, in this part of the code), instead of keeping all responses if multiple calls to process_single_turn_with_tools are made.

indeed I forgot to remove this part. See my comment here #2986 (comment).

The reason is that self.client stores an HTTP response object each time it make a request: so better cleaning this resource after the request/response has been handled (here, in this part of the code), instead of keeping all responses if multiple calls to process_single_turn_with_tools are made.

Currently, if process_single_turn_with_tools is called in parallel you might get unexpected behaviors because of a used connection being closed abruptly. In practice, the InferenceClient won't really have many unclosed sessions in parallel. They are already well garbage collected except in the case of a non-awaited streaming response - which shouldn' occur.

src/huggingface_hub/inference/_mcp/mcp_client.py

julien-c · 2025-05-16T13:19:31Z

src/huggingface_hub/inference/_mcp/utils.py

cc @evalstate

julien-c

lgtm, feel free to merge and release whenever you want!

julien-c · 2025-05-16T13:26:44Z

src/huggingface_hub/inference/_mcp/mcp_client.py

+        warnings.warn(
+            "'MCPClient' is experimental and might be subject to breaking changes in the future without prior notice.",
+            UserWarning,
+        )


personally think we could omit this, but no strong opinion

moved it the docstring

julien-c · 2025-05-16T14:20:20Z

Pinging @albertvillanova for a quick review too if you have time!

src/huggingface_hub/inference/_mcp/mcp_client.py

evalstate · 2025-05-16T15:40:01Z

src/huggingface_hub/inference/_mcp/utils.py

Tested with plaintext, image generator and audio generator (returning as EmbeddedResource). LGTM.

albertvillanova · 2025-05-16T16:06:10Z

I would love to have a look at it this weekend.

albertvillanova

Thanks a lot for this addition! It is great that we finally have a Hugging Face MCP client: this will definitely make experimentation and integration much smoother.

I know this has already been discussed and there's no strong consensus, but I'd still like to share my opinion here for the record: as we've talked about privately, I feel that this is more than a simple MCP client: in my humble view, it already constitutes a single-step agent due to the use of an LLM. A multi-step agent could then be built by looping over this single step. That said, I realize this is mostly a matter of terminology in a space that's evolving really quickly, so it's not a big deal at all, just a remark worth surfacing.

On a more concrete note, I'd love to suggest that we consider supporting use cases that don't involve an LLM. For example, I'm thinking of scenarios where a user wants to build a code agent rather than a tool-calling agent, similar to what we do in smolagents, where tools are passed as Python functions and the model generates code that uses them.

With this in mind, do you think it would make sense to also provide a sync version of the client? That could make it much easier to support tools exposed as synchronous Python functions and to integrate into existing sync workflows.

Curious to hear your thoughts. And thanks again for pushing this forward!

src/huggingface_hub/inference/_mcp/mcp_client.py

albertvillanova · 2025-05-19T04:57:30Z

src/huggingface_hub/inference/_mcp/mcp_client.py

+        for tool in response.tools:
+            if tool.name in self.sessions:
+                logger.warning(f"Tool '{tool.name}' already defined by another server. Skipping.")
+                continue


I think we should eventually consider supporting tools with the same name coming from different servers. One possible approach could be to prepend the server name to the tool name to ensure uniqueness.
This could be explored in a future PR.

Yes agree 👍 (been mentioned above but for now post-poned for later PR as you said)

albertvillanova · 2025-05-19T05:04:01Z

src/huggingface_hub/inference/_mcp/mcp_client.py

+
+    async def __aenter__(self):
+        """Enter the context manager"""
+        await self.client.__aenter__()


What is the point of entering the client context manager here?

It is only used within the process_single_turn_with_tools method, and the context manager is properly entered and exit there using a with block?

Suggested change

await self.client.__aenter__()

Good catch! I initially intended to delete the async with self.client: below but forgot about it. The issue with including async with self.client: within process_single_turn_with_tools is that concurrent usage of process_single_turn_with_tools may result in unexpected behaviors if one instance terminates the sessions for all others. By relocating the logic to __aenter__, the responsibility shifts to the end user, who can handle the client lifecycle themselves.

updated in b273cba

src/huggingface_hub/inference/_mcp/mcp_client.py

albertvillanova · 2025-05-19T05:19:52Z

src/huggingface_hub/inference/_mcp/mcp_client.py

+            tools = [*exit_loop_tools, *self.available_tools]
+
+        # Create the streaming request
+        async with self.client:


See my comment above: I proposed keeping the with block here and removing the self.client from the __aenter__ above.
The reason is that self.client stores an HTTP response object each time it make a request: so better cleaning this resource after the request/response has been handled (here, in this part of the code), instead of keeping all responses if multiple calls to process_single_turn_with_tools are made.

julien-c · 2025-05-19T11:45:29Z

I feel that this is more than a simple MCP client: in my humble view, it already constitutes a single-step agent due to the use of an LLM

I disagree: the official example of MCP Client does have a LLM: https://modelcontextprotocol.io/quickstart/client

Without a LLM, a bare MCP client would just be a standard JSON-over-RPC call ; IMO MCP is LLM-centric.

already constitutes a single-step agent

For me Agent === multi-step, otherwise it's just LLM with tool calling.

Wauplin · 2025-05-20T14:58:40Z

I addressed all the comments above and fixed the resources lifecycle (user decides when to open/close connections).

Re: should the MCP client include an LLM, I do think that yes and I would argue that this is what an HF-based MCP client is for (i.e. the goal is to have minimal code to glue MCP servers to Inference Providers). Regarding exposing the MCP tools as python functions for a code agent, that can be explored separately I think (either in a separate class or with this class but with a separate method). I'm still unfamiliar with code agents and what they would expect from MCP Client.

TL;DR: are we finally ready to merge this? 😄

Wauplin

I like self-approvals.

hanouticelina

🔥 🔥 🔥

julien-c added 2 commits April 8, 2025 13:05

Add extra dependency

c720d86

PoC: InferenceClient is also a MCPClient

a0be544

julien-c requested a review from mishig25 April 8, 2025 12:51

[using Claude] change the code to make MCPClient inherit from AsyncIn…

2c7329c

…ferenceClient

mishig25 reviewed Apr 8, 2025

View reviewed changes

mcp_client.py Outdated Show resolved Hide resolved

julien-c and others added 5 commits April 8, 2025 16:20

Update mcp_client.py

cef1bba

Co-authored-by: Mishig <[email protected]>

mcp_client: Support multiple servers (#2987)

42f036e

cc @mishig25

Revert "[using Claude] change the code to make MCPClient inherit from…

990a926

… AsyncInferenceClient" This reverts commit 2c7329c.

add_mcp_server: the env should not be hardcoded here

879d2ee

cc @Wauplin

Handle the "no tool call" case

9ee3c68

julien-c mentioned this pull request Apr 11, 2025

PoC: InferenceClient is also a McpClient huggingface/huggingface.js#1351

Merged

grll reviewed Apr 16, 2025

View reviewed changes

grll reviewed Apr 18, 2025

View reviewed changes

mcp_client.py Outdated Show resolved Hide resolved

Wauplin reviewed Apr 23, 2025

View reviewed changes

julien-c mentioned this pull request May 2, 2025

Support for TinyAgent mozilla-ai/any-agent#166

Closed

njbrake mentioned this pull request May 3, 2025

Python Implementation of TinyAgent #3046

Closed

Wauplin and others added 7 commits May 13, 2025 15:42

Merge branch 'main' into mcp-client

c827256

Update setup.py

e5d205b

Merge branch 'mcp-client' of github.com:huggingface/huggingface_hub i…

7c08143

…nto mcp-client

Async mcp client + example + code quality

67304ce

docstring

3d422f8

accept ChatCompletionInputMessage as input

1a12eb5

Merge branch 'main' into mcp-client

1f2181c

Wauplin requested review from Wauplin, Pierrci and grll May 13, 2025 18:13

Wauplin added 2 commits May 13, 2025 20:14

style

ff1d39b

better type

bc8448d

Wauplin added 2 commits May 13, 2025 20:21

no need mcp for dev

b03ef86

code quality on Python 3.8

5d9af3a

hanouticelina reviewed May 15, 2025

View reviewed changes

julien-c commented May 16, 2025

View reviewed changes

src/huggingface_hub/inference/_mcp/utils.py Outdated

Copy link

Member Author

julien-c May 16, 2025

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

cc @evalstate

julien-c commented May 16, 2025

View reviewed changes

julien-c requested review from albertvillanova and removed request for grll May 16, 2025 14:20

evalstate reviewed May 16, 2025

View reviewed changes

src/huggingface_hub/inference/_mcp/mcp_client.py Outdated Show resolved Hide resolved

evalstate reviewed May 16, 2025

View reviewed changes

albertvillanova approved these changes May 19, 2025

View reviewed changes

Wauplin added 6 commits May 20, 2025 15:41

Merge branch 'main' into mcp-client

ee648eb

address feedback

0d6981a

address feedback

63a37f9

do not close client inside of �[200~process_single_turn_with_tools~

b273cba

docstring, no more warning, garbage collection

834cef2

docs

b3ea2ee

Wauplin approved these changes May 20, 2025

View reviewed changes

hanouticelina approved these changes May 20, 2025

View reviewed changes

Wauplin merged commit a5e089c into main May 20, 2025
25 checks passed

Wauplin deleted the mcp-client branch May 20, 2025 15:17

	logger.debug("Connected to server with tools:", [tool.name for tool in response.tools])
	logger.debug("Connected to server with tools: %s", [tool.name for tool in response.tools])

PoC: InferenceClient is also a MCPClient #2986

PoC: InferenceClient is also a MCPClient #2986

Uh oh!

Conversation

julien-c commented Apr 8, 2025 • edited by Wauplin Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Required reading

Summary of how to use this

Open questions

Where to find the MCP Server used here as an example

Script output

3D Model Generation from Text

Best Paper on Transformers

Uh oh!

HuggingFaceDocBuilderDev commented Apr 8, 2025

Uh oh!

mishig25 Apr 8, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

mishig25 Apr 8, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Option 1

Option 2

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

grll left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

julien-c Apr 17, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

julien-c commented Apr 17, 2025

Uh oh!

grll commented Apr 18, 2025

Uh oh!

julien-c commented Apr 18, 2025

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Wauplin commented May 13, 2025 • edited by julien-c Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

PoC: `InferenceClient` is also a `MCPClient` #2986

PoC: `InferenceClient` is also a `MCPClient` #2986

julien-c commented Apr 8, 2025 •

edited by Wauplin

Loading

mishig25 Apr 8, 2025 •

edited

Loading

mishig25 Apr 8, 2025 •

edited

Loading

julien-c Apr 17, 2025 •

edited

Loading

Wauplin commented May 13, 2025 •

edited by julien-c

Loading

hanouticelina left a comment •

edited

Loading

albertvillanova commented May 16, 2025 •

edited

Loading

Wauplin May 20, 2025 •

edited

Loading