diff --git a/letta/client/client.py b/letta/client/client.py
index 35b0c6f6..201b3017 100644
--- a/letta/client/client.py
+++ b/letta/client/client.py
@@ -810,7 +810,7 @@ class RESTClient(AbstractClient):
         Returns:
             memory (Memory): In-context memory of the agent
         """
-        response = requests.get(f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/core_memory", headers=self.headers)
+        response = requests.get(f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/core-memory", headers=self.headers)
         if response.status_code != 200:
             raise ValueError(f"Failed to get in-context memory: {response.text}")
         return Memory(**response.json())
@@ -831,7 +831,7 @@ class RESTClient(AbstractClient):
         """
         memory_update_dict = {section: value}
         response = requests.patch(
-            f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/core_memory", json=memory_update_dict, headers=self.headers
+            f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/core-memory", json=memory_update_dict, headers=self.headers
         )
         if response.status_code != 200:
             raise ValueError(f"Failed to update in-context memory: {response.text}")
@@ -924,7 +924,7 @@ class RESTClient(AbstractClient):
         if after:
             params["after"] = str(after)
         response = requests.get(
-            f"{self.base_url}/{self.api_prefix}/agents/{str(agent_id)}/archival_memory", params=params, headers=self.headers
+            f"{self.base_url}/{self.api_prefix}/agents/{str(agent_id)}/archival-memory", params=params, headers=self.headers
         )
         assert response.status_code == 200, f"Failed to get archival memory: {response.text}"
         return [Passage(**passage) for passage in response.json()]
@@ -942,7 +942,7 @@ class RESTClient(AbstractClient):
         """
         request = CreateArchivalMemory(text=memory)
         response = requests.post(
-            f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/archival_memory", headers=self.headers, json=request.model_dump()
+            f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/archival-memory", headers=self.headers, json=request.model_dump()
         )
         if response.status_code != 200:
             raise ValueError(f"Failed to insert archival memory: {response.text}")
@@ -956,7 +956,7 @@ class RESTClient(AbstractClient):
             agent_id (str): ID of the agent
             memory_id (str): ID of the memory
         """
-        response = requests.delete(f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/archival_memory/{memory_id}", headers=self.headers)
+        response = requests.delete(f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/archival-memory/{memory_id}", headers=self.headers)
         assert response.status_code == 200, f"Failed to delete archival memory: {response.text}"
 
     # messages (recall memory)
@@ -1906,7 +1906,7 @@ class RESTClient(AbstractClient):
             block_id (str): ID of the block to attach
         """
         response = requests.patch(
-            f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/core_memory/blocks/attach/{block_id}",
+            f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/core-memory/blocks/attach/{block_id}",
             headers=self.headers,
         )
         if response.status_code != 200:
@@ -1922,7 +1922,7 @@ class RESTClient(AbstractClient):
             block_id (str): ID of the block to detach
         """
         response = requests.patch(
-            f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/core_memory/blocks/detach/{block_id}", headers=self.headers
+            f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/core-memory/blocks/detach/{block_id}", headers=self.headers
         )
         if response.status_code != 200:
             raise ValueError(f"Failed to detach block from agent: {response.text}")
@@ -1938,7 +1938,7 @@ class RESTClient(AbstractClient):
         Returns:
             blocks (List[Block]): The blocks in the agent's core memory
         """
-        response = requests.get(f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/core_memory/blocks", headers=self.headers)
+        response = requests.get(f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/core-memory/blocks", headers=self.headers)
         if response.status_code != 200:
             raise ValueError(f"Failed to get agent memory blocks: {response.text}")
         return [Block(**block) for block in response.json()]
@@ -1955,7 +1955,7 @@ class RESTClient(AbstractClient):
             block (Block): The block corresponding to the label
         """
         response = requests.get(
-            f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/core_memory/blocks/{label}",
+            f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/core-memory/blocks/{label}",
             headers=self.headers,
         )
         if response.status_code != 200:
@@ -1988,7 +1988,7 @@ class RESTClient(AbstractClient):
         if limit:
             data["limit"] = limit
         response = requests.patch(
-            f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/core_memory/blocks/{label}",
+            f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/core-memory/blocks/{label}",
             headers=self.headers,
             json=data,
         )
diff --git a/letta/server/rest_api/routers/v1/agents.py b/letta/server/rest_api/routers/v1/agents.py
index dcc3ca71..4d3720dd 100644
--- a/letta/server/rest_api/routers/v1/agents.py
+++ b/letta/server/rest_api/routers/v1/agents.py
@@ -70,8 +70,8 @@ def list_agents(
     return agents
 
 
-@router.get("/{agent_id}/context", response_model=ContextWindowOverview, operation_id="get_agent_context_window")
-def get_agent_context_window(
+@router.get("/{agent_id}/context", response_model=ContextWindowOverview, operation_id="retrieve_agent_context_window")
+def retrieve_agent_context_window(
     agent_id: str,
     server: "SyncServer" = Depends(get_letta_server),
     user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
@@ -106,8 +106,8 @@ def create_agent(
     return server.create_agent(agent, actor=actor)
 
 
-@router.patch("/{agent_id}", response_model=AgentState, operation_id="update_agent")
-def update_agent(
+@router.patch("/{agent_id}", response_model=AgentState, operation_id="modify_agent")
+def modify_agent(
     agent_id: str,
     update_agent: UpdateAgent = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
@@ -118,8 +118,8 @@ def update_agent(
     return server.agent_manager.update_agent(agent_id=agent_id, agent_update=update_agent, actor=actor)
 
 
-@router.get("/{agent_id}/tools", response_model=List[Tool], operation_id="get_tools_from_agent")
-def get_tools_from_agent(
+@router.get("/{agent_id}/tools", response_model=List[Tool], operation_id="list_agent_tools")
+def list_agent_tools(
     agent_id: str,
     server: "SyncServer" = Depends(get_letta_server),
     user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
@@ -129,7 +129,7 @@ def get_tools_from_agent(
     return server.agent_manager.list_attached_tools(agent_id=agent_id, actor=actor)
 
 
-@router.patch("/{agent_id}/tools/attach/{tool_id}", response_model=AgentState, operation_id="attach_tool_to_agent")
+@router.patch("/{agent_id}/tools/attach/{tool_id}", response_model=AgentState, operation_id="attach_tool")
 def attach_tool(
     agent_id: str,
     tool_id: str,
@@ -143,7 +143,7 @@ def attach_tool(
     return server.agent_manager.attach_tool(agent_id=agent_id, tool_id=tool_id, actor=actor)
 
 
-@router.patch("/{agent_id}/tools/detach/{tool_id}", response_model=AgentState, operation_id="detach_tool_from_agent")
+@router.patch("/{agent_id}/tools/detach/{tool_id}", response_model=AgentState, operation_id="detach_tool")
 def detach_tool(
     agent_id: str,
     tool_id: str,
@@ -185,8 +185,8 @@ def detach_source(
     return server.agent_manager.detach_source(agent_id=agent_id, source_id=source_id, actor=actor)
 
 
-@router.get("/{agent_id}", response_model=AgentState, operation_id="get_agent")
-def get_agent_state(
+@router.get("/{agent_id}", response_model=AgentState, operation_id="retrieve_agent")
+def retrieve_agent(
     agent_id: str,
     server: "SyncServer" = Depends(get_letta_server),
     user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
@@ -219,8 +219,8 @@ def delete_agent(
         raise HTTPException(status_code=404, detail=f"Agent agent_id={agent_id} not found for user_id={actor.id}.")
 
 
-@router.get("/{agent_id}/sources", response_model=List[Source], operation_id="get_agent_sources")
-def get_agent_sources(
+@router.get("/{agent_id}/sources", response_model=List[Source], operation_id="list_agent_sources")
+def list_agent_sources(
     agent_id: str,
     server: "SyncServer" = Depends(get_letta_server),
     user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
@@ -233,8 +233,8 @@ def get_agent_sources(
 
 
 # TODO: remove? can also get with agent blocks
-@router.get("/{agent_id}/core_memory", response_model=Memory, operation_id="get_agent_memory")
-def get_agent_memory(
+@router.get("/{agent_id}/core-memory", response_model=Memory, operation_id="retrieve_agent_memory")
+def retrieve_agent_memory(
     agent_id: str,
     server: "SyncServer" = Depends(get_letta_server),
     user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
@@ -248,8 +248,8 @@ def get_agent_memory(
     return server.get_agent_memory(agent_id=agent_id, actor=actor)
 
 
-@router.get("/{agent_id}/core_memory/blocks/{block_label}", response_model=Block, operation_id="get_agent_memory_block")
-def get_agent_memory_block(
+@router.get("/{agent_id}/core-memory/blocks/{block_label}", response_model=Block, operation_id="retrieve_core_memory_block")
+def retrieve_core_memory_block(
     agent_id: str,
     block_label: str,
     server: "SyncServer" = Depends(get_letta_server),
@@ -266,8 +266,8 @@ def get_agent_memory_block(
         raise HTTPException(status_code=404, detail=str(e))
 
 
-@router.get("/{agent_id}/core_memory/blocks", response_model=List[Block], operation_id="list_agent_memory_blocks")
-def list_agent_memory_blocks(
+@router.get("/{agent_id}/core-memory/blocks", response_model=List[Block], operation_id="list_core_memory_blocks")
+def list_core_memory_blocks(
     agent_id: str,
     server: "SyncServer" = Depends(get_letta_server),
     user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
@@ -283,8 +283,8 @@ def list_agent_memory_blocks(
         raise HTTPException(status_code=404, detail=str(e))
 
 
-@router.patch("/{agent_id}/core_memory/blocks/{block_label}", response_model=Block, operation_id="update_agent_memory_block_by_label")
-def update_agent_memory_block(
+@router.patch("/{agent_id}/core-memory/blocks/{block_label}", response_model=Block, operation_id="modify_core_memory_block")
+def modify_core_memory_block(
     agent_id: str,
     block_label: str,
     block_update: BlockUpdate = Body(...),
@@ -305,8 +305,8 @@ def update_agent_memory_block(
     return block
 
 
-@router.patch("/{agent_id}/core_memory/blocks/attach/{block_id}", response_model=AgentState, operation_id="attach_block_to_agent")
-def attach_block(
+@router.patch("/{agent_id}/core-memory/blocks/attach/{block_id}", response_model=AgentState, operation_id="attach_core_memory_block")
+def attach_core_memory_block(
     agent_id: str,
     block_id: str,
     server: "SyncServer" = Depends(get_letta_server),
@@ -319,8 +319,8 @@ def attach_block(
     return server.agent_manager.attach_block(agent_id=agent_id, block_id=block_id, actor=actor)
 
 
-@router.patch("/{agent_id}/core_memory/blocks/detach/{block_id}", response_model=AgentState, operation_id="detach_block_from_agent")
-def detach_block(
+@router.patch("/{agent_id}/core-memory/blocks/detach/{block_id}", response_model=AgentState, operation_id="detach_core_memory_block")
+def detach_core_memory_block(
     agent_id: str,
     block_id: str,
     server: "SyncServer" = Depends(get_letta_server),
@@ -333,8 +333,8 @@ def detach_block(
     return server.agent_manager.detach_block(agent_id=agent_id, block_id=block_id, actor=actor)
 
 
-@router.get("/{agent_id}/archival_memory", response_model=List[Passage], operation_id="list_agent_archival_memory")
-def get_agent_archival_memory(
+@router.get("/{agent_id}/archival-memory", response_model=List[Passage], operation_id="list_archival_memory")
+def list_archival_memory(
     agent_id: str,
     server: "SyncServer" = Depends(get_letta_server),
     after: Optional[int] = Query(None, description="Unique ID of the memory to start the query range at."),
@@ -359,8 +359,8 @@ def get_agent_archival_memory(
     )
 
 
-@router.post("/{agent_id}/archival_memory", response_model=List[Passage], operation_id="create_agent_archival_memory")
-def insert_agent_archival_memory(
+@router.post("/{agent_id}/archival-memory", response_model=List[Passage], operation_id="create_archival_memory")
+def create_archival_memory(
     agent_id: str,
     request: CreateArchivalMemory = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
@@ -376,8 +376,8 @@ def insert_agent_archival_memory(
 
 # TODO(ethan): query or path parameter for memory_id?
 # @router.delete("/{agent_id}/archival")
-@router.delete("/{agent_id}/archival_memory/{memory_id}", response_model=None, operation_id="delete_agent_archival_memory")
-def delete_agent_archival_memory(
+@router.delete("/{agent_id}/archival-memory/{memory_id}", response_model=None, operation_id="delete_archival_memory")
+def delete_archival_memory(
     agent_id: str,
     memory_id: str,
     # memory_id: str = Query(..., description="Unique ID of the memory to be deleted."),
@@ -406,8 +406,8 @@ AgentMessagesResponse = Annotated[
 ]
 
 
-@router.get("/{agent_id}/messages", response_model=AgentMessagesResponse, operation_id="list_agent_messages")
-def get_agent_messages(
+@router.get("/{agent_id}/messages", response_model=AgentMessagesResponse, operation_id="list_messages")
+def list_messages(
     agent_id: str,
     server: "SyncServer" = Depends(get_letta_server),
     before: Optional[str] = Query(None, description="Message before which to retrieve the returned messages."),
@@ -441,8 +441,8 @@ def get_agent_messages(
     )
 
 
-@router.patch("/{agent_id}/messages/{message_id}", response_model=Message, operation_id="update_agent_message")
-def update_message(
+@router.patch("/{agent_id}/messages/{message_id}", response_model=Message, operation_id="modify_message")
+def modify_message(
     agent_id: str,
     message_id: str,
     request: MessageUpdate = Body(...),
@@ -460,7 +460,7 @@ def update_message(
 @router.post(
     "/{agent_id}/messages",
     response_model=LettaResponse,
-    operation_id="create_agent_message",
+    operation_id="send_message",
 )
 async def send_message(
     agent_id: str,
diff --git a/letta/server/rest_api/routers/v1/blocks.py b/letta/server/rest_api/routers/v1/blocks.py
index ba9e1aef..2d261f39 100644
--- a/letta/server/rest_api/routers/v1/blocks.py
+++ b/letta/server/rest_api/routers/v1/blocks.py
@@ -13,7 +13,7 @@ if TYPE_CHECKING:
 router = APIRouter(prefix="/blocks", tags=["blocks"])
 
 
-@router.get("/", response_model=List[Block], operation_id="list_memory_blocks")
+@router.get("/", response_model=List[Block], operation_id="list_blocks")
 def list_blocks(
     # query parameters
     label: Optional[str] = Query(None, description="Labels to include (e.g. human, persona)"),
@@ -26,7 +26,7 @@ def list_blocks(
     return server.block_manager.get_blocks(actor=actor, label=label, is_template=templates_only, template_name=name)
 
 
-@router.post("/", response_model=Block, operation_id="create_memory_block")
+@router.post("/", response_model=Block, operation_id="create_block")
 def create_block(
     create_block: CreateBlock = Body(...),
     server: SyncServer = Depends(get_letta_server),
@@ -37,8 +37,8 @@ def create_block(
     return server.block_manager.create_or_update_block(actor=actor, block=block)
 
 
-@router.patch("/{block_id}", response_model=Block, operation_id="update_memory_block")
-def update_block(
+@router.patch("/{block_id}", response_model=Block, operation_id="modify_block")
+def modify_block(
     block_id: str,
     block_update: BlockUpdate = Body(...),
     server: SyncServer = Depends(get_letta_server),
@@ -48,7 +48,7 @@ def update_block(
     return server.block_manager.update_block(block_id=block_id, block_update=block_update, actor=actor)
 
 
-@router.delete("/{block_id}", response_model=Block, operation_id="delete_memory_block")
+@router.delete("/{block_id}", response_model=Block, operation_id="delete_block")
 def delete_block(
     block_id: str,
     server: SyncServer = Depends(get_letta_server),
@@ -58,8 +58,8 @@ def delete_block(
     return server.block_manager.delete_block(block_id=block_id, actor=actor)
 
 
-@router.get("/{block_id}", response_model=Block, operation_id="get_memory_block")
-def get_block(
+@router.get("/{block_id}", response_model=Block, operation_id="retrieve_block")
+def retrieve_block(
     block_id: str,
     server: SyncServer = Depends(get_letta_server),
     user_id: Optional[str] = Header(None, alias="user_id"),
diff --git a/letta/server/rest_api/routers/v1/jobs.py b/letta/server/rest_api/routers/v1/jobs.py
index 4245d2f9..9e6cc78f 100644
--- a/letta/server/rest_api/routers/v1/jobs.py
+++ b/letta/server/rest_api/routers/v1/jobs.py
@@ -45,8 +45,8 @@ def list_active_jobs(
     return server.job_manager.list_jobs(actor=actor, statuses=[JobStatus.created, JobStatus.running])
 
 
-@router.get("/{job_id}", response_model=Job, operation_id="get_job")
-def get_job(
+@router.get("/{job_id}", response_model=Job, operation_id="retrieve_job")
+def retrieve_job(
     job_id: str,
     user_id: Optional[str] = Header(None, alias="user_id"),
     server: "SyncServer" = Depends(get_letta_server),
diff --git a/letta/server/rest_api/routers/v1/providers.py b/letta/server/rest_api/routers/v1/providers.py
index 2a0ef515..be462dbf 100644
--- a/letta/server/rest_api/routers/v1/providers.py
+++ b/letta/server/rest_api/routers/v1/providers.py
@@ -45,8 +45,8 @@ def create_provider(
     return provider
 
 
-@router.patch("/", tags=["providers"], response_model=Provider, operation_id="update_provider")
-def update_provider(
+@router.patch("/", tags=["providers"], response_model=Provider, operation_id="modify_provider")
+def modify_provider(
     request: ProviderUpdate = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
 ):
diff --git a/letta/server/rest_api/routers/v1/runs.py b/letta/server/rest_api/routers/v1/runs.py
index 63bd404f..6af01c5e 100644
--- a/letta/server/rest_api/routers/v1/runs.py
+++ b/letta/server/rest_api/routers/v1/runs.py
@@ -43,8 +43,8 @@ def list_active_runs(
     return [Run.from_job(job) for job in active_runs]
 
 
-@router.get("/{run_id}", response_model=Run, operation_id="get_run")
-def get_run(
+@router.get("/{run_id}", response_model=Run, operation_id="retrieve_run")
+def retrieve_run(
     run_id: str,
     user_id: Optional[str] = Header(None, alias="user_id"),
     server: "SyncServer" = Depends(get_letta_server),
@@ -69,9 +69,9 @@ RunMessagesResponse = Annotated[
 @router.get(
     "/{run_id}/messages",
     response_model=RunMessagesResponse,
-    operation_id="get_run_messages",
+    operation_id="list_run_messages",
 )
-async def get_run_messages(
+async def list_run_messages(
     run_id: str,
     server: "SyncServer" = Depends(get_letta_server),
     user_id: Optional[str] = Header(None, alias="user_id"),
@@ -111,8 +111,8 @@ async def get_run_messages(
         raise HTTPException(status_code=404, detail=str(e))
 
 
-@router.get("/{run_id}/usage", response_model=UsageStatistics, operation_id="get_run_usage")
-def get_run_usage(
+@router.get("/{run_id}/usage", response_model=UsageStatistics, operation_id="retrieve_run_usage")
+def retrieve_run_usage(
     run_id: str,
     user_id: Optional[str] = Header(None, alias="user_id"),
     server: "SyncServer" = Depends(get_letta_server),
diff --git a/letta/server/rest_api/routers/v1/sources.py b/letta/server/rest_api/routers/v1/sources.py
index 0d721359..b4c0e841 100644
--- a/letta/server/rest_api/routers/v1/sources.py
+++ b/letta/server/rest_api/routers/v1/sources.py
@@ -19,8 +19,8 @@ from letta.utils import sanitize_filename
 router = APIRouter(prefix="/sources", tags=["sources"])
 
 
-@router.get("/{source_id}", response_model=Source, operation_id="get_source")
-def get_source(
+@router.get("/{source_id}", response_model=Source, operation_id="retrieve_source")
+def retrieve_source(
     source_id: str,
     server: "SyncServer" = Depends(get_letta_server),
     user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
@@ -81,8 +81,8 @@ def create_source(
     return server.source_manager.create_source(source=source, actor=actor)
 
 
-@router.patch("/{source_id}", response_model=Source, operation_id="update_source")
-def update_source(
+@router.patch("/{source_id}", response_model=Source, operation_id="modify_source")
+def modify_source(
     source_id: str,
     source: SourceUpdate,
     server: "SyncServer" = Depends(get_letta_server),
@@ -148,7 +148,7 @@ def upload_file_to_source(
 
 
 @router.get("/{source_id}/passages", response_model=List[Passage], operation_id="list_source_passages")
-def list_passages(
+def list_source_passages(
     source_id: str,
     server: SyncServer = Depends(get_letta_server),
     user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
@@ -161,8 +161,8 @@ def list_passages(
     return passages
 
 
-@router.get("/{source_id}/files", response_model=List[FileMetadata], operation_id="list_files_from_source")
-def list_files_from_source(
+@router.get("/{source_id}/files", response_model=List[FileMetadata], operation_id="list_source_files")
+def list_source_files(
     source_id: str,
     limit: int = Query(1000, description="Number of files to return"),
     cursor: Optional[str] = Query(None, description="Pagination cursor to fetch the next set of results"),
diff --git a/letta/server/rest_api/routers/v1/tags.py b/letta/server/rest_api/routers/v1/tags.py
index b052ef82..bbdfa881 100644
--- a/letta/server/rest_api/routers/v1/tags.py
+++ b/letta/server/rest_api/routers/v1/tags.py
@@ -12,7 +12,7 @@ router = APIRouter(prefix="/tags", tags=["tag", "admin"])
 
 
 @router.get("/", tags=["admin"], response_model=List[str], operation_id="list_tags")
-def get_tags(
+def list_tags(
     cursor: Optional[str] = Query(None),
     limit: Optional[int] = Query(50),
     server: "SyncServer" = Depends(get_letta_server),
diff --git a/letta/server/rest_api/routers/v1/tools.py b/letta/server/rest_api/routers/v1/tools.py
index 6a2310ae..ce05e5bc 100644
--- a/letta/server/rest_api/routers/v1/tools.py
+++ b/letta/server/rest_api/routers/v1/tools.py
@@ -31,8 +31,8 @@ def delete_tool(
     server.tool_manager.delete_tool_by_id(tool_id=tool_id, actor=actor)
 
 
-@router.get("/{tool_id}", response_model=Tool, operation_id="get_tool")
-def get_tool(
+@router.get("/{tool_id}", response_model=Tool, operation_id="retrieve_tool")
+def retrieve_tool(
     tool_id: str,
     server: SyncServer = Depends(get_letta_server),
     user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
@@ -122,8 +122,8 @@ def upsert_tool(
         raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}")
 
 
-@router.patch("/{tool_id}", response_model=Tool, operation_id="update_tool")
-def update_tool(
+@router.patch("/{tool_id}", response_model=Tool, operation_id="modify_tool")
+def modify_tool(
     tool_id: str,
     request: ToolUpdate = Body(...),
     server: SyncServer = Depends(get_letta_server),