Broad rearrangement of handlers

2026-03-12 00:44:17 -04:00
parent 2e058035f3
commit d69fc4cd1e
98 changed files with 270 additions and 1032 deletions
--- a/Plugins/BlueprintMCP/Deprecated/UMCPHandler_AddMaterialExpression.h
+++ b/Plugins/BlueprintMCP/Deprecated/UMCPHandler_AddMaterialExpression.h
@@ -0,0 +1,169 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "MCPHandler.h"
+#include "MCPAssetFinder.h"
+#include "MCPUtils.h"
+#include "Materials/Material.h"
+#include "Materials/MaterialFunction.h"
+#include "Materials/MaterialExpression.h"
+#include "MaterialGraph/MaterialGraph.h"
+#include "MaterialGraph/MaterialGraphNode.h"
+#include "UObject/UObjectIterator.h"
+#include "UMCPHandler_AddMaterialExpression.generated.h"
+
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+
+UCLASS(meta=(Group="Unclassified"))
+class UMCPHandler_AddMaterialExpression : public UObject, public IMCPHandler
+{
+	GENERATED_BODY()
+
+public:
+	UPROPERTY(meta=(Optional, Description="Material name or package path (specify this or materialFunction, not both)"))
+	FString Material;
+
+	UPROPERTY(meta=(Optional, Description="Material function name or package path (specify this or material, not both)"))
+	FString MaterialFunction;
+
+	UPROPERTY(meta=(Description="Expression class name without 'MaterialExpression' prefix (e.g. 'Constant', 'ScalarParameter', 'Add', 'Multiply', 'Lerp')"))
+	FString ExpressionClass;
+
+	UPROPERTY(meta=(Optional, Description="X position in the material graph editor"))
+	int32 PosX = 0;
+
+	UPROPERTY(meta=(Optional, Description="Y position in the material graph editor"))
+	int32 PosY = 0;
+
+	virtual FString GetDescription() const override
+	{
+		return TEXT("Add a new expression node to a material or material function graph.");
+	}
+
+	virtual void Handle(const FJsonObject* Json, FStringBuilderBase& Result) override
+	{
+		if (Material.IsEmpty() && MaterialFunction.IsEmpty())
+		{
+			Result.Append(TEXT("ERROR: Specify 'material' or 'materialFunction'\n"));
+			return;
+		}
+		if (!Material.IsEmpty() && !MaterialFunction.IsEmpty())
+		{
+			Result.Append(TEXT("ERROR: Specify 'material' or 'materialFunction', not both\n"));
+			return;
+		}
+
+		// Resolve the expression class
+		UClass* ExprClass = ResolveExpressionClass(Result);
+		if (!ExprClass) return;
+
+		// Load material or material function
+		UMaterial* MaterialObj = nullptr;
+		UMaterialFunction* MatFunc = nullptr;
+		UObject* Owner = nullptr;
+
+		if (!MaterialFunction.IsEmpty())
+		{
+			MCPAssets<UMaterialFunction> Assets;
+			if (!Assets.Exact(MaterialFunction).Errors(Result).ENone().ETwo().Load()) return;
+			MatFunc = Assets.Object();
+			Owner = MatFunc;
+		}
+		else
+		{
+			MCPAssets<UMaterial> Assets;
+			if (!Assets.Exact(Material).Errors(Result).ENone().ETwo().Load()) return;
+			MaterialObj = Assets.Object();
+			Owner = MaterialObj;
+		}
+
+		// Ensure the MaterialGraph exists (commandlet mode doesn't auto-create it)
+		if (MaterialObj) MCPUtils::EnsureMaterialGraph(MaterialObj);
+
+		// Create the expression
+		UMaterialExpression* NewExpr = NewObject<UMaterialExpression>(Owner, ExprClass);
+		if (!NewExpr)
+		{
+			Result.Append(TEXT("ERROR: Failed to create material expression object\n"));
+			return;
+		}
+		NewExpr->MaterialExpressionEditorX = PosX;
+		NewExpr->MaterialExpressionEditorY = PosY;
+
+		if (MaterialObj)
+		{
+			MaterialObj->GetExpressionCollection().AddExpression(NewExpr);
+			if (MaterialObj->MaterialGraph)
+				MaterialObj->MaterialGraph->RebuildGraph();
+			MaterialObj->PreEditChange(nullptr);
+			MaterialObj->PostEditChange();
+			MaterialObj->MarkPackageDirty();
+		}
+		else
+		{
+			MatFunc->GetExpressionCollection().AddExpression(NewExpr);
+			MatFunc->PreEditChange(nullptr);
+			MatFunc->PostEditChange();
+			MatFunc->MarkPackageDirty();
+		}
+
+		// Save
+		bool bSaved = MaterialObj
+			? MCPUtils::SaveMaterialPackage(MaterialObj)
+			: MCPUtils::SaveGenericPackage(MatFunc);
+
+		// Output
+		Result.Appendf(TEXT("Added %s\n"), *MCPUtils::FormatName(NewExpr));
+
+		// Find the graph node GUID (only for materials with a material graph)
+		if (MaterialObj && MaterialObj->MaterialGraph)
+		{
+			for (UEdGraphNode* Node : MaterialObj->MaterialGraph->Nodes)
+			{
+				UMaterialGraphNode* MatNode = Cast<UMaterialGraphNode>(Node);
+				if (MatNode && MatNode->MaterialExpression == NewExpr)
+				{
+					Result.Appendf(TEXT("NodeId: %s\n"), *Node->NodeGuid.ToString());
+					break;
+				}
+			}
+		}
+
+		if (!bSaved)
+			Result.Append(TEXT("WARNING: Failed to save package\n"));
+	}
+
+private:
+	UClass* ResolveExpressionClass(FStringBuilderBase& Result)
+	{
+		// Convenience aliases
+		static TMap<FString, FString> Aliases = {
+			{TEXT("Lerp"), TEXT("LinearInterpolate")},
+		};
+
+		FString LookupName = ExpressionClass;
+		if (const FString* Alias = Aliases.Find(ExpressionClass))
+			LookupName = *Alias;
+
+		FString FullClassName = FString::Printf(TEXT("MaterialExpression%s"), *LookupName);
+		for (TObjectIterator<UClass> It; It; ++It)
+		{
+			if (It->GetName() == FullClassName && It->IsChildOf(UMaterialExpression::StaticClass()))
+			{
+				if (It->HasAnyClassFlags(CLASS_Abstract))
+				{
+					Result.Appendf(TEXT("ERROR: Expression class '%s' is abstract\n"), *ExpressionClass);
+					return nullptr;
+				}
+				return *It;
+			}
+		}
+
+		Result.Appendf(TEXT("ERROR: Unknown expression class '%s'. Use the UMaterialExpression subclass name without the 'MaterialExpression' prefix (e.g. 'Constant', 'ScalarParameter', 'Add', 'Multiply', 'Lerp')\n"),
+			*ExpressionClass);
+		return nullptr;
+	}
+};
--- a/Plugins/BlueprintMCP/Deprecated/UMCPHandler_AddStructField.h
+++ b/Plugins/BlueprintMCP/Deprecated/UMCPHandler_AddStructField.h
@@ -0,0 +1,72 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "MCPHandler.h"
+#include "MCPFetcher.h"
+#include "MCPUtils.h"
+#include "StructUtils/UserDefinedStruct.h"
+#include "UserDefinedStructure/UserDefinedStructEditorData.h"
+#include "UMCPHandler_AddStructField.generated.h"
+
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+
+UCLASS(meta=(Group="Unclassified"))
+class UMCPHandler_AddStructField : public UObject, public IMCPHandler
+{
+	GENERATED_BODY()
+
+public:
+	UPROPERTY(meta=(Description="Package path of the struct asset"))
+	FString Struct;
+
+	UPROPERTY(meta=(Description="Name for the new field"))
+	FString Name;
+
+	UPROPERTY(meta=(Description="Type for the new field (e.g. 'int32', 'FString', 'FVector')"))
+	FString Type;
+
+	virtual FString GetDescription() const override
+	{
+		return TEXT("Add a new field to a UserDefinedStruct asset.");
+	}
+
+	virtual void Handle(const FJsonObject* Json, FStringBuilderBase& Result) override
+	{
+		// Find the struct
+		MCPFetcher F(Result);
+		UUserDefinedStruct* S = F.Walk(Struct).Cast<UUserDefinedStruct>();
+		if (!S) return;
+
+		// Resolve type
+		FEdGraphPinType PinType;
+		if (!MCPUtils::ResolveTypeFromString(Type, PinType, Result))
+			return;
+
+		// Snapshot existing GUIDs so we can find the newly added one
+		TSet<FGuid> ExistingGuids;
+		for (const FStructVariableDescription& Var : FStructureEditorUtils::GetVarDesc(S))
+			ExistingGuids.Add(Var.VarGuid);
+
+		if (!FStructureEditorUtils::AddVariable(S, PinType))
+		{
+			Result.Append(TEXT("ERROR: Failed to add field to struct.\n"));
+			return;
+		}
+
+		// Find the new variable by diffing GUID sets and rename it
+		for (const FStructVariableDescription& Var : FStructureEditorUtils::GetVarDesc(S))
+		{
+			if (!ExistingGuids.Contains(Var.VarGuid))
+			{
+				FStructureEditorUtils::RenameVariable(S, Var.VarGuid, Name);
+				break;
+			}
+		}
+
+		MCPUtils::SaveGenericPackage(S);
+		Result.Appendf(TEXT("Added field: %s %s\n"), *Type, *Name);
+	}
+};
--- a/Plugins/BlueprintMCP/Deprecated/UMCPHandler_BlueprintSearchTypeUsage.h
+++ b/Plugins/BlueprintMCP/Deprecated/UMCPHandler_BlueprintSearchTypeUsage.h
@@ -0,0 +1,229 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "MCPHandler.h"
+#include "MCPAssetFinder.h"
+#include "MCPUtils.h"
+#include "Engine/Blueprint.h"
+#include "Engine/World.h"
+#include "Engine/Level.h"
+#include "Engine/LevelScriptBlueprint.h"
+#include "EdGraph/EdGraph.h"
+#include "EdGraph/EdGraphNode.h"
+#include "K2Node_CallFunction.h"
+#include "K2Node_Event.h"
+#include "K2Node_CustomEvent.h"
+#include "K2Node_VariableGet.h"
+#include "K2Node_VariableSet.h"
+#include "K2Node_BreakStruct.h"
+#include "K2Node_MakeStruct.h"
+#include "K2Node_FunctionEntry.h"
+#include "K2Node_EditablePinBase.h"
+#include "AssetRegistry/IAssetRegistry.h"
+#include "UMCPHandler_BlueprintSearchTypeUsage.generated.h"
+
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+
+// ============================================================
+// HandleSearchByType — find all usages of a type across blueprints
+// ============================================================
+
+UCLASS(meta=(Group="Blueprint"))
+class UMCPHandler_BlueprintSearchTypeUsage : public UObject, public IMCPHandler
+{
+	GENERATED_BODY()
+
+public:
+	UPROPERTY(meta=(Description="Type name to search for (e.g. 'FVector', 'MyStruct'). F/E/U prefix is stripped for matching."))
+	FString TypeName;
+
+	UPROPERTY(meta=(Optional, Description="Filter to blueprints whose name or path contains this substring"))
+	FString Query;
+
+	UPROPERTY(meta=(Optional, Description="Maximum number of results to return (default 200, max 500)"))
+	int32 MaxResults = 0;
+
+	virtual FString GetDescription() const override
+	{
+		return TEXT("Search all Blueprints for usages of a specific type in variables, function parameters, struct nodes, and pin connections.");
+	}
+
+	virtual void Handle(const FJsonObject* Json, FStringBuilderBase& Result) override
+	{
+		FString DecodedTypeName = MCPUtils::UrlDecode(TypeName);
+		FString FilterStr = Query.IsEmpty() ? FString() : MCPUtils::UrlDecode(Query);
+
+		int32 EffectiveMaxResults = (MaxResults > 0) ? FMath::Clamp(MaxResults, 1, 500) : 200;
+
+		// Strip F/E/U prefix for comparison
+		FString TypeNameNoPrefix = DecodedTypeName;
+		if (TypeNameNoPrefix.StartsWith(TEXT("F")) || TypeNameNoPrefix.StartsWith(TEXT("E")) || TypeNameNoPrefix.StartsWith(TEXT("U")))
+		{
+			TypeNameNoPrefix = TypeNameNoPrefix.Mid(1);
+		}
+
+		auto MatchesType = [&DecodedTypeName, &TypeNameNoPrefix](const FString& TestType) -> bool
+		{
+			return TestType.Equals(DecodedTypeName, ESearchCase::IgnoreCase) ||
+				TestType.Equals(TypeNameNoPrefix, ESearchCase::IgnoreCase);
+		};
+
+		int32 ResultCount = 0;
+
+		// Helper: get subtype name from a pin type
+		auto GetSubtype = [](const FEdGraphPinType& PinType) -> FString
+		{
+			if (PinType.PinSubCategoryObject.IsValid())
+				return PinType.PinSubCategoryObject->GetName();
+			return FString();
+		};
+
+		// Helper: check if a pin type matches
+		auto PinTypeMatches = [&](const FEdGraphPinType& PinType) -> bool
+		{
+			return MatchesType(GetSubtype(PinType)) || MatchesType(PinType.PinCategory.ToString());
+		};
+
+		// Lambda that searches a single Blueprint for type usages
+		auto SearchOneBlueprint = [&](UBlueprint* BP, bool bIsLevel)
+		{
+			FString BPName = MCPUtils::FormatName(BP);
+
+			// Check variables
+			for (const FBPVariableDescription& Var : BP->NewVariables)
+			{
+				if (ResultCount >= EffectiveMaxResults) return;
+				if (!PinTypeMatches(Var.VarType)) continue;
+
+				Result.Appendf(TEXT("variable %s in %s: %s %s\n"),
+					*MCPUtils::FormatName(Var), *BPName,
+					*Var.VarType.PinCategory.ToString(), *GetSubtype(Var.VarType));
+				ResultCount++;
+			}
+
+			// Check graphs for function/event params, struct nodes, and pin connections
+			for (UEdGraphNode* Node : MCPUtils::AllNodes(BP))
+			{
+				if (ResultCount >= EffectiveMaxResults) return;
+
+				// Check FunctionEntry parameters
+				if (auto* FuncEntry = Cast<UK2Node_FunctionEntry>(Node))
+				{
+					for (const TSharedPtr<FUserPinInfo>& PinInfo : FuncEntry->UserDefinedPins)
+					{
+						if (!PinInfo.IsValid()) continue;
+						if (!PinTypeMatches(PinInfo->PinType)) continue;
+
+						Result.Appendf(TEXT("func-param %s.%s in %s: %s %s\n"),
+							*MCPUtils::FormatName(Node->GetGraph()), *PinInfo->PinName.ToString(),
+							*BPName,
+							*PinInfo->PinType.PinCategory.ToString(), *GetSubtype(PinInfo->PinType));
+						ResultCount++;
+					}
+				}
+				else if (auto* CustomEvent = Cast<UK2Node_CustomEvent>(Node))
+				{
+					for (const TSharedPtr<FUserPinInfo>& PinInfo : CustomEvent->UserDefinedPins)
+					{
+						if (!PinInfo.IsValid()) continue;
+						if (!PinTypeMatches(PinInfo->PinType)) continue;
+
+						Result.Appendf(TEXT("event-param %s.%s in %s: %s %s\n"),
+							*MCPUtils::FormatName(Node), *PinInfo->PinName.ToString(),
+							*BPName,
+							*PinInfo->PinType.PinCategory.ToString(), *GetSubtype(PinInfo->PinType));
+						ResultCount++;
+					}
+				}
+				// Check Break/Make struct nodes
+				else if (auto* BreakNode = Cast<UK2Node_BreakStruct>(Node))
+				{
+					if (BreakNode->StructType && MatchesType(BreakNode->StructType->GetName()))
+					{
+						Result.Appendf(TEXT("break-struct %s in %s graph %s\n"),
+							*BreakNode->StructType->GetName(), *BPName,
+							*MCPUtils::FormatName(Node->GetGraph()));
+						ResultCount++;
+					}
+				}
+				else if (auto* MakeNode = Cast<UK2Node_MakeStruct>(Node))
+				{
+					if (MakeNode->StructType && MatchesType(MakeNode->StructType->GetName()))
+					{
+						Result.Appendf(TEXT("make-struct %s in %s graph %s\n"),
+							*MakeNode->StructType->GetName(), *BPName,
+							*MCPUtils::FormatName(Node->GetGraph()));
+						ResultCount++;
+					}
+				}
+
+				// Check pin connections carrying the type
+				for (UEdGraphPin* Pin : Node->Pins)
+				{
+					if (!Pin || Pin->bHidden || ResultCount >= EffectiveMaxResults) continue;
+					if (Pin->LinkedTo.Num() == 0) continue;
+					if (!PinTypeMatches(Pin->PinType)) continue;
+
+					Result.Appendf(TEXT("pin %s.%s in %s graph %s: %s %s (%d connections)\n"),
+						*MCPUtils::FormatName(Node), *MCPUtils::FormatName(Pin),
+						*BPName, *MCPUtils::FormatName(Node->GetGraph()),
+						*Pin->PinType.PinCategory.ToString(), *GetSubtype(Pin->PinType),
+						Pin->LinkedTo.Num());
+					ResultCount++;
+				}
+			}
+		};
+
+		MCPAssets<UBlueprint> AllBlueprints;
+		AllBlueprints.Info();
+		MCPAssets<UWorld> AllWorlds;
+		AllWorlds.Info();
+
+		// Search regular blueprints
+		for (const FAssetData& Asset : AllBlueprints.AllData())
+		{
+			if (ResultCount >= EffectiveMaxResults) break;
+
+			FString AssetPath = Asset.PackageName.ToString();
+			FString AssetName = Asset.AssetName.ToString();
+
+			if (!FilterStr.IsEmpty() && !AssetName.Contains(FilterStr, ESearchCase::IgnoreCase) &&
+				!AssetPath.Contains(FilterStr, ESearchCase::IgnoreCase))
+			{
+				continue;
+			}
+
+			UBlueprint* BP = Cast<UBlueprint>(const_cast<FAssetData&>(Asset).GetAsset());
+			if (!BP) continue;
+
+			SearchOneBlueprint(BP, false);
+		}
+
+		// Search level blueprints from maps
+		for (const FAssetData& MapAsset : AllWorlds.AllData())
+		{
+			if (ResultCount >= EffectiveMaxResults) break;
+
+			FString AssetPath = MapAsset.PackageName.ToString();
+			FString MapName = MapAsset.AssetName.ToString();
+
+			if (!FilterStr.IsEmpty() && !MapName.Contains(FilterStr, ESearchCase::IgnoreCase) &&
+				!AssetPath.Contains(FilterStr, ESearchCase::IgnoreCase))
+			{
+				continue;
+			}
+
+			UWorld* World = Cast<UWorld>(MapAsset.GetAsset());
+			if (!World || !World->PersistentLevel) continue;
+			ULevelScriptBlueprint* LevelBP = World->PersistentLevel->GetLevelScriptBlueprint(false);
+			if (!LevelBP) continue;
+
+			SearchOneBlueprint(LevelBP, true);
+		}
+
+		Result.Appendf(TEXT("\n%d results\n"), ResultCount);
+	}
+};
--- a/Plugins/BlueprintMCP/Deprecated/UMCPHandler_ConnectMaterialExpressionPins.h
+++ b/Plugins/BlueprintMCP/Deprecated/UMCPHandler_ConnectMaterialExpressionPins.h
@@ -0,0 +1,188 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "MCPHandler.h"
+#include "MCPAssetFinder.h"
+#include "MCPUtils.h"
+#include "Materials/Material.h"
+#include "Materials/MaterialFunction.h"
+#include "Materials/MaterialExpression.h"
+#include "MaterialGraph/MaterialGraph.h"
+#include "EdGraph/EdGraph.h"
+#include "EdGraph/EdGraphNode.h"
+#include "UMCPHandler_ConnectMaterialExpressionPins.generated.h"
+
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+
+USTRUCT()
+struct FConnectMaterialPinsEntry
+{
+	GENERATED_BODY()
+
+	UPROPERTY()
+	FString SourceNode;
+
+	UPROPERTY()
+	FString SourcePin;
+
+	UPROPERTY()
+	FString TargetNode;
+
+	UPROPERTY()
+	FString TargetPin;
+};
+
+
+UCLASS(meta=(Group="Unclassified"))
+class UMCPHandler_ConnectMaterialExpressionPins : public UObject, public IMCPHandler
+{
+	GENERATED_BODY()
+
+public:
+	UPROPERTY(meta=(Optional, Description="Material name or package path (specify this or materialFunction)"))
+	FString Material;
+
+	UPROPERTY(meta=(Optional, Description="Material function name or package path (specify this or material)"))
+	FString MaterialFunction;
+
+	UPROPERTY(meta=(Description="Array of {sourceNode, sourcePin, targetNode, targetPin} objects"))
+	FMCPJsonArray Connections;
+
+	virtual FString GetDescription() const override
+	{
+		return TEXT("Connect pins between nodes in a material or material function graph. Supports batching.");
+	}
+
+	virtual void Handle(const FJsonObject* Json, FStringBuilderBase& Result) override
+	{
+		if (Material.IsEmpty() && MaterialFunction.IsEmpty())
+		{
+			Result.Append(TEXT("ERROR: Specify 'material' or 'materialFunction'.\n"));
+			return;
+		}
+
+		// Load material or material function
+		UMaterial* MaterialObj = nullptr;
+		UMaterialFunction* MatFunc = nullptr;
+
+		if (!MaterialFunction.IsEmpty())
+		{
+			MCPAssets<UMaterialFunction> Assets;
+			if (!Assets.Exact(MaterialFunction).Errors(Result).ENone().ETwo().Load()) return;
+			MatFunc = Assets.Object();
+		}
+		else
+		{
+			MCPAssets<UMaterial> Assets;
+			if (!Assets.Exact(Material).Errors(Result).ENone().ETwo().Load()) return;
+			MaterialObj = Assets.Object();
+		}
+
+		if (MaterialObj) MCPUtils::EnsureMaterialGraph(MaterialObj);
+		UEdGraph* Graph = MaterialObj ? (UEdGraph*)MaterialObj->MaterialGraph : (MatFunc ? MatFunc->MaterialGraph : nullptr);
+		if (!Graph)
+		{
+			Result.Appendf(TEXT("ERROR: %s has no material graph.\n"),
+				MaterialObj ? *MCPUtils::FormatName(MaterialObj) : *MCPUtils::FormatName(MatFunc));
+			return;
+		}
+
+		int32 SuccessCount = 0;
+		const UEdGraphSchema* Schema = Graph->GetSchema();
+
+		for (const TSharedPtr<FJsonValue>& ConnVal : Connections.Array)
+		{
+			FConnectMaterialPinsEntry Entry;
+			if (!MCPUtils::PopulateFromJson(FConnectMaterialPinsEntry::StaticStruct(), &Entry, ConnVal, MCPErrorCallback(Result)))
+				continue;
+
+			// Find source node
+			UEdGraphNode* SrcNode = FindNodeByName(Graph, Entry.SourceNode);
+			if (!SrcNode)
+			{
+				Result.Appendf(TEXT("ERROR: Source node '%s' not found.\n"), *Entry.SourceNode);
+				continue;
+			}
+
+			// Find target node
+			UEdGraphNode* TgtNode = FindNodeByName(Graph, Entry.TargetNode);
+			if (!TgtNode)
+			{
+				Result.Appendf(TEXT("ERROR: Target node '%s' not found.\n"), *Entry.TargetNode);
+				continue;
+			}
+
+			// Find source pin
+			UEdGraphPin* SrcPin = FindPinByName(SrcNode, Entry.SourcePin);
+			if (!SrcPin)
+			{
+				Result.Appendf(TEXT("ERROR: Pin '%s' not found on %s. Available:"),
+					*Entry.SourcePin, *MCPUtils::FormatName(SrcNode));
+				for (UEdGraphPin* P : SrcNode->Pins)
+					if (P) Result.Appendf(TEXT(" %s"), *MCPUtils::FormatName(P));
+				Result.Append(TEXT("\n"));
+				continue;
+			}
+
+			// Find target pin
+			UEdGraphPin* TgtPin = FindPinByName(TgtNode, Entry.TargetPin);
+			if (!TgtPin)
+			{
+				Result.Appendf(TEXT("ERROR: Pin '%s' not found on %s. Available:"),
+					*Entry.TargetPin, *MCPUtils::FormatName(TgtNode));
+				for (UEdGraphPin* P : TgtNode->Pins)
+					if (P) Result.Appendf(TEXT(" %s"), *MCPUtils::FormatName(P));
+				Result.Append(TEXT("\n"));
+				continue;
+			}
+
+			// Check compatibility
+			const FPinConnectionResponse Response = Schema->CanCreateConnection(SrcPin, TgtPin);
+			if (Response.Response == CONNECT_RESPONSE_DISALLOW)
+			{
+				Result.Appendf(TEXT("ERROR: Cannot connect %s.%s -> %s.%s: %s\n"),
+					*MCPUtils::FormatName(SrcNode), *MCPUtils::FormatName(SrcPin),
+					*MCPUtils::FormatName(TgtNode), *MCPUtils::FormatName(TgtPin),
+					*Response.Message.ToString());
+				continue;
+			}
+
+			Schema->TryCreateConnection(SrcPin, TgtPin);
+			SuccessCount++;
+		}
+
+		if (SuccessCount > 0)
+		{
+			UObject* Asset = MaterialObj ? (UObject*)MaterialObj : (UObject*)MatFunc;
+			Asset->PreEditChange(nullptr);
+			Asset->PostEditChange();
+			bool bSaved = MaterialObj ? MCPUtils::SaveMaterialPackage(MaterialObj) : MCPUtils::SaveGenericPackage(MatFunc);
+			Result.Appendf(TEXT("Connected %d/%d. Saved: %s\n"),
+				SuccessCount, Connections.Array.Num(), bSaved ? TEXT("yes") : TEXT("no"));
+		}
+		else
+		{
+			Result.Appendf(TEXT("0/%d connections succeeded.\n"), Connections.Array.Num());
+		}
+	}
+
+private:
+	UEdGraphNode* FindNodeByName(UEdGraph* Graph, const FString& Name)
+	{
+		for (UEdGraphNode* Node : Graph->Nodes)
+			if (Node && MCPUtils::Identifies(Name, Node))
+				return Node;
+		return nullptr;
+	}
+
+	UEdGraphPin* FindPinByName(UEdGraphNode* Node, const FString& Name)
+	{
+		for (UEdGraphPin* Pin : Node->Pins)
+			if (Pin && MCPUtils::Identifies(Name, Pin))
+				return Pin;
+		return nullptr;
+	}
+};
--- a/Plugins/BlueprintMCP/Deprecated/UMCPHandler_DeleteMaterialExpression.h
+++ b/Plugins/BlueprintMCP/Deprecated/UMCPHandler_DeleteMaterialExpression.h
@@ -0,0 +1,126 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "MCPHandler.h"
+#include "MCPAssetFinder.h"
+#include "MCPUtils.h"
+#include "Materials/Material.h"
+#include "Materials/MaterialExpression.h"
+#include "Materials/MaterialFunction.h"
+#include "MaterialGraph/MaterialGraph.h"
+#include "MaterialGraph/MaterialGraphNode.h"
+#include "UMCPHandler_DeleteMaterialExpression.generated.h"
+
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+
+UCLASS(meta=(Group="Unclassified"))
+class UMCPHandler_DeleteMaterialExpression : public UObject, public IMCPHandler
+{
+	GENERATED_BODY()
+
+public:
+	UPROPERTY(meta=(Optional, Description="Material name or package path (specify this or materialFunction)"))
+	FString Material;
+
+	UPROPERTY(meta=(Optional, Description="Material function name or package path (specify this or material)"))
+	FString MaterialFunction;
+
+	UPROPERTY(meta=(Description="Expression name (use FormatName from DumpMaterial output)"))
+	FString Node;
+
+	UPROPERTY(meta=(Optional, Description="If true, preview the change without applying it"))
+	bool DryRun = false;
+
+	virtual FString GetDescription() const override
+	{
+		return TEXT("Remove an expression node from a material or material function graph.");
+	}
+
+	virtual void Handle(const FJsonObject* Json, FStringBuilderBase& Result) override
+	{
+		if (Material.IsEmpty() && MaterialFunction.IsEmpty())
+		{
+			MCPErrorCallback(Result).SetError(TEXT("Specify 'material' or 'materialFunction'."));
+			return;
+		}
+
+		// Load material or material function
+		UMaterial* MaterialObj = nullptr;
+		UMaterialFunction* MatFunc = nullptr;
+
+		if (!MaterialFunction.IsEmpty())
+		{
+			MCPAssets<UMaterialFunction> MFAssets;
+			if (!MFAssets.Exact(MaterialFunction).Errors(Result).ENone().ETwo().Load()) return;
+			MatFunc = MFAssets.Object();
+		}
+		else
+		{
+			MCPAssets<UMaterial> MatAssets;
+			if (!MatAssets.Exact(Material).Errors(Result).ENone().ETwo().Load()) return;
+			MaterialObj = MatAssets.Object();
+		}
+
+		if (MaterialObj) MCPUtils::EnsureMaterialGraph(MaterialObj);
+		UEdGraph* Graph = MaterialObj ? (UEdGraph*)MaterialObj->MaterialGraph : (MatFunc ? MatFunc->MaterialGraph : nullptr);
+		if (!Graph)
+		{
+			MCPErrorCallback(Result).SetError(TEXT("Asset has no material graph."));
+			return;
+		}
+
+		// Find node by name
+		UMaterialGraphNode* TargetMatNode = nullptr;
+		for (UEdGraphNode* GraphNode : Graph->Nodes)
+		{
+			if (!GraphNode) continue;
+			UMaterialGraphNode* MatNode = Cast<UMaterialGraphNode>(GraphNode);
+			if (!MatNode || !MatNode->MaterialExpression) continue;
+			if (MCPUtils::Identifies(Node, MatNode->MaterialExpression))
+			{
+				TargetMatNode = MatNode;
+				break;
+			}
+		}
+
+		if (!TargetMatNode)
+		{
+			MCPErrorCallback(Result).SetError(FString::Printf(TEXT("Expression '%s' not found."), *Node));
+			return;
+		}
+
+		FString ExprName = MCPUtils::FormatName(TargetMatNode->MaterialExpression);
+
+		if (DryRun)
+		{
+			Result.Appendf(TEXT("DryRun: would delete %s\n"), *ExprName);
+			return;
+		}
+
+		// Remove the expression
+		UMaterialExpression* ExprToRemove = TargetMatNode->MaterialExpression;
+		if (MaterialObj)
+			MaterialObj->GetExpressionCollection().RemoveExpression(ExprToRemove);
+		else
+			MatFunc->GetExpressionCollection().RemoveExpression(ExprToRemove);
+		ExprToRemove->MarkAsGarbage();
+
+		// Rebuild graph
+		Graph->NotifyGraphChanged();
+
+		UObject* Asset = MaterialObj ? (UObject*)MaterialObj : (UObject*)MatFunc;
+		Asset->PreEditChange(nullptr);
+		Asset->PostEditChange();
+		Asset->MarkPackageDirty();
+
+		// Save
+		bool bSaved = MaterialObj ? MCPUtils::SaveMaterialPackage(MaterialObj) : MCPUtils::SaveGenericPackage(MatFunc);
+
+		Result.Appendf(TEXT("Deleted %s"), *ExprName);
+		if (!bSaved) Result.Append(TEXT(" (save failed)"));
+		Result.Append(TEXT("\n"));
+	}
+};
--- a/Plugins/BlueprintMCP/Deprecated/UMCPHandler_DescribeMaterialInEnglish.h
+++ b/Plugins/BlueprintMCP/Deprecated/UMCPHandler_DescribeMaterialInEnglish.h
@@ -0,0 +1,188 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "MCPHandler.h"
+#include "MCPAssetFinder.h"
+#include "MCPUtils.h"
+#include "Materials/Material.h"
+#include "Materials/MaterialExpression.h"
+#include "Materials/MaterialExpressionScalarParameter.h"
+#include "Materials/MaterialExpressionVectorParameter.h"
+#include "Materials/MaterialExpressionTextureObjectParameter.h"
+#include "Materials/MaterialExpressionTextureSampleParameter2D.h"
+#include "Materials/MaterialExpressionStaticSwitchParameter.h"
+#include "Materials/MaterialExpressionConstant.h"
+#include "Materials/MaterialExpressionConstant3Vector.h"
+#include "Materials/MaterialExpressionConstant4Vector.h"
+#include "Materials/MaterialExpressionTextureSample.h"
+#include "Materials/MaterialExpressionMaterialFunctionCall.h"
+#include "Materials/MaterialFunction.h"
+#include "MaterialGraph/MaterialGraph.h"
+#include "MaterialGraph/MaterialGraphNode.h"
+#include "MaterialGraph/MaterialGraphNode_Root.h"
+#include "MaterialGraph/MaterialGraphSchema.h"
+#include "EdGraph/EdGraph.h"
+#include "EdGraph/EdGraphNode.h"
+#include "UMCPHandler_DescribeMaterialInEnglish.generated.h"
+
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+
+UCLASS(meta=(Group="Unclassified"))
+class UMCPHandler_DescribeMaterialInEnglish : public UObject, public IMCPHandler
+{
+	GENERATED_BODY()
+
+public:
+	UPROPERTY(meta=(Description="Material name or package path"))
+	FString Material;
+
+	virtual FString GetDescription() const override
+	{
+		return TEXT("Generate a human-readable description of a material by tracing its expression graph from the root node inputs.");
+	}
+
+	virtual void Handle(const FJsonObject* Json, FStringBuilderBase& Result) override
+	{
+		MCPAssets<UMaterial> Assets;
+		if (!Assets.Exact(Material).Errors(Result).ENone().ETwo().Load()) return;
+		UMaterial* MaterialObj = Assets.Object();
+
+		// Ensure material graph is built
+		MCPUtils::EnsureMaterialGraph(MaterialObj);
+		if (!MaterialObj->MaterialGraph)
+		{
+			MCPErrorCallback(Result).SetError(TEXT("Could not build MaterialGraph for this material"));
+			return;
+		}
+
+		// Find root node
+		UMaterialGraphNode_Root* RootNode = nullptr;
+		for (UEdGraphNode* Node : MaterialObj->MaterialGraph->Nodes)
+		{
+			RootNode = Cast<UMaterialGraphNode_Root>(Node);
+			if (RootNode) break;
+		}
+		if (!RootNode)
+		{
+			MCPErrorCallback(Result).SetError(TEXT("Could not find root node in material graph"));
+			return;
+		}
+
+		// Recursive helper: trace backwards from a pin and build a description string
+		TFunction<FString(UEdGraphPin*, int32)> TracePin = [&TracePin](UEdGraphPin* Pin, int32 Depth) -> FString
+		{
+			if (!Pin || Depth > 10)
+				return TEXT("(unknown)");
+
+			if (Pin->LinkedTo.Num() == 0)
+			{
+				if (!Pin->DefaultValue.IsEmpty())
+					return FString::Printf(TEXT("(default: %s)"), *Pin->DefaultValue);
+				return TEXT("(unconnected)");
+			}
+
+			TArray<FString> Sources;
+			for (UEdGraphPin* LinkedPin : Pin->LinkedTo)
+			{
+				if (!LinkedPin || !LinkedPin->GetOwningNode()) continue;
+
+				UEdGraphNode* SourceNode = LinkedPin->GetOwningNode();
+				FString NodeDesc;
+
+				UMaterialGraphNode* MatNode = Cast<UMaterialGraphNode>(SourceNode);
+				if (!MatNode)
+				{
+					NodeDesc = MCPUtils::FormatName(SourceNode);
+					Sources.Add(NodeDesc);
+					continue;
+				}
+
+				UMaterialExpression* Expr = MatNode->MaterialExpression;
+				if (!Expr)
+				{
+					NodeDesc = TEXT("(null expression)");
+				}
+				else if (auto* SP = Cast<UMaterialExpressionScalarParameter>(Expr))
+				{
+					NodeDesc = FString::Printf(TEXT("ScalarParam \"%s\" (default: %.4f)"), *SP->ParameterName.ToString(), SP->DefaultValue);
+				}
+				else if (auto* VP = Cast<UMaterialExpressionVectorParameter>(Expr))
+				{
+					NodeDesc = FString::Printf(TEXT("VectorParam \"%s\" (default: R=%.2f G=%.2f B=%.2f A=%.2f)"),
+						*VP->ParameterName.ToString(), VP->DefaultValue.R, VP->DefaultValue.G, VP->DefaultValue.B, VP->DefaultValue.A);
+				}
+				else if (auto* TP = Cast<UMaterialExpressionTextureSampleParameter2D>(Expr))
+				{
+					FString TexName = TP->Texture ? MCPUtils::FormatName(TP->Texture) : TEXT("None");
+					NodeDesc = FString::Printf(TEXT("TextureParam \"%s\" (%s)"), *TP->ParameterName.ToString(), *TexName);
+				}
+				else if (auto* SSP = Cast<UMaterialExpressionStaticSwitchParameter>(Expr))
+				{
+					NodeDesc = FString::Printf(TEXT("StaticSwitchParam \"%s\" (default: %s)"),
+						*SSP->ParameterName.ToString(), SSP->DefaultValue ? TEXT("true") : TEXT("false"));
+				}
+				else if (auto* SC = Cast<UMaterialExpressionConstant>(Expr))
+				{
+					NodeDesc = FString::Printf(TEXT("Constant(%.4f)"), SC->R);
+				}
+				else if (auto* C3 = Cast<UMaterialExpressionConstant3Vector>(Expr))
+				{
+					NodeDesc = FString::Printf(TEXT("Constant3(R=%.2f G=%.2f B=%.2f)"), C3->Constant.R, C3->Constant.G, C3->Constant.B);
+				}
+				else if (auto* C4 = Cast<UMaterialExpressionConstant4Vector>(Expr))
+				{
+					NodeDesc = FString::Printf(TEXT("Constant4(R=%.2f G=%.2f B=%.2f A=%.2f)"), C4->Constant.R, C4->Constant.G, C4->Constant.B, C4->Constant.A);
+				}
+				else if (auto* TS = Cast<UMaterialExpressionTextureSample>(Expr))
+				{
+					FString TexName = TS->Texture ? MCPUtils::FormatName(TS->Texture) : TEXT("None");
+					NodeDesc = FString::Printf(TEXT("TextureSample(%s)"), *TexName);
+				}
+				else if (auto* MFC = Cast<UMaterialExpressionMaterialFunctionCall>(Expr))
+				{
+					FString FuncName = MFC->MaterialFunction ? MFC->MaterialFunction->GetPathName() : TEXT("None");
+					NodeDesc = FString::Printf(TEXT("FunctionCall(%s)"), *FuncName);
+				}
+				else
+				{
+					NodeDesc = MCPUtils::FormatName(Expr);
+				}
+
+				// Recurse into input pins
+				TArray<FString> InputDescs;
+				for (UEdGraphPin* InputPin : SourceNode->Pins)
+				{
+					if (!InputPin || InputPin->Direction != EGPD_Input || InputPin->LinkedTo.Num() == 0) continue;
+					InputDescs.Add(TracePin(InputPin, Depth + 1));
+				}
+				if (InputDescs.Num() > 0)
+				{
+					NodeDesc += TEXT(" <- (") + FString::Join(InputDescs, TEXT(", ")) + TEXT(")");
+				}
+
+				Sources.Add(NodeDesc);
+			}
+
+			if (Sources.Num() == 1)
+				return Sources[0];
+
+			return TEXT("(") + FString::Join(Sources, TEXT(", ")) + TEXT(")");
+		};
+
+		// Trace each connected root input and output plain text
+		Result.Appendf(TEXT("Material: %s\n\n"), *MCPUtils::FormatName(MaterialObj));
+
+		for (UEdGraphPin* Pin : RootNode->Pins)
+		{
+			if (!Pin || Pin->Direction != EGPD_Input) continue;
+			if (Pin->LinkedTo.Num() == 0) continue;
+
+			FString PinName = MCPUtils::FormatName(Pin);
+			FString Description = TracePin(Pin, 0);
+			Result.Appendf(TEXT("%s <- %s\n"), *PinName, *Description);
+		}
+	}
+};
--- a/Plugins/BlueprintMCP/Deprecated/UMCPHandler_DisconnectMaterialExpressionPin.h
+++ b/Plugins/BlueprintMCP/Deprecated/UMCPHandler_DisconnectMaterialExpressionPin.h
@@ -0,0 +1,98 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "MCPHandler.h"
+#include "MCPAssetFinder.h"
+#include "MCPFetcher.h"
+#include "MCPUtils.h"
+#include "Materials/Material.h"
+#include "Materials/MaterialExpression.h"
+#include "Materials/MaterialFunction.h"
+#include "MaterialGraph/MaterialGraph.h"
+#include "EdGraph/EdGraph.h"
+#include "EdGraph/EdGraphNode.h"
+#include "EdGraph/EdGraphPin.h"
+#include "UMCPHandler_DisconnectMaterialExpressionPin.generated.h"
+
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+
+UCLASS(meta=(Group="Unclassified"))
+class UMCPHandler_DisconnectMaterialExpressionPin : public UObject, public IMCPHandler
+{
+	GENERATED_BODY()
+
+public:
+	UPROPERTY(meta=(Optional, Description="Material name or package path (specify this or materialFunction)"))
+	FString Material;
+
+	UPROPERTY(meta=(Optional, Description="Material function name or package path (specify this or material)"))
+	FString MaterialFunction;
+
+	UPROPERTY(meta=(Description="Node name (use FormatName-style identifier)"))
+	FString Node;
+
+	UPROPERTY(meta=(Description="Pin name to disconnect"))
+	FString PinName;
+
+	virtual FString GetDescription() const override
+	{
+		return TEXT("Break all connections on a specific pin in a material or material function graph.");
+	}
+
+	virtual void Handle(const FJsonObject* Json, FStringBuilderBase& Result) override
+	{
+		if (Material.IsEmpty() && MaterialFunction.IsEmpty())
+		{
+			Result.Append(TEXT("ERROR: Specify 'material' or 'materialFunction'.\n"));
+			return;
+		}
+
+		// Load material or material function
+		UMaterial* MaterialObj = nullptr;
+		UMaterialFunction* MatFunc = nullptr;
+
+		if (!MaterialFunction.IsEmpty())
+		{
+			MCPAssets<UMaterialFunction> Assets;
+			if (!Assets.Exact(MaterialFunction).Errors(Result).ENone().ETwo().Load()) return;
+			MatFunc = Assets.Object();
+		}
+		else
+		{
+			MCPAssets<UMaterial> Assets;
+			if (!Assets.Exact(Material).Errors(Result).ENone().ETwo().Load()) return;
+			MaterialObj = Assets.Object();
+		}
+
+		if (MaterialObj) MCPUtils::EnsureMaterialGraph(MaterialObj);
+		UEdGraph* Graph = MaterialObj ? (UEdGraph*)MaterialObj->MaterialGraph : (MatFunc ? MatFunc->MaterialGraph : nullptr);
+		if (!Graph)
+		{
+			Result.Appendf(TEXT("ERROR: %s has no material graph.\n"),
+				MaterialObj ? *MCPUtils::FormatName(MaterialObj) : *MCPUtils::FormatName(MatFunc));
+			return;
+		}
+
+		// Find node and pin via MCPFetcher
+		MCPFetcher F(Result, Graph);
+		UEdGraphPin* Pin = F.Node(Node).Pin(PinName).Cast<UEdGraphPin>();
+		if (!Pin) return;
+
+		int32 BrokenCount = Pin->LinkedTo.Num();
+		Pin->BreakAllPinLinks();
+
+		UObject* Asset = MaterialObj ? (UObject*)MaterialObj : (UObject*)MatFunc;
+		Asset->PreEditChange(nullptr);
+		Asset->PostEditChange();
+
+		bool bSaved = MaterialObj ? MCPUtils::SaveMaterialPackage(MaterialObj) : MCPUtils::SaveGenericPackage(MatFunc);
+
+		Result.Appendf(TEXT("Disconnected %d link(s) from %s on %s.\n"),
+			BrokenCount, *MCPUtils::FormatName(Pin), *MCPUtils::FormatName(Pin->GetOwningNode()));
+		if (!bSaved)
+			Result.Append(TEXT("WARNING: Failed to save package.\n"));
+	}
+};
--- a/Plugins/BlueprintMCP/Deprecated/UMCPHandler_DumpMaterial.h
+++ b/Plugins/BlueprintMCP/Deprecated/UMCPHandler_DumpMaterial.h
@@ -0,0 +1,228 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "MCPHandler.h"
+#include "MCPAssetFinder.h"
+#include "MCPUtils.h"
+#include "Materials/Material.h"
+#include "MaterialDomain.h"
+#include "Materials/MaterialInstanceConstant.h"
+#include "Materials/MaterialExpression.h"
+#include "Materials/MaterialExpressionScalarParameter.h"
+#include "Materials/MaterialExpressionVectorParameter.h"
+#include "Materials/MaterialExpressionTextureSampleParameter2D.h"
+#include "Materials/MaterialExpressionStaticSwitchParameter.h"
+#include "Materials/MaterialExpressionTextureSample.h"
+#include "Engine/Texture.h"
+#include "UMCPHandler_DumpMaterial.generated.h"
+
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+
+UCLASS(meta=(Group="Unclassified"))
+class UMCPHandler_DumpMaterial : public UObject, public IMCPHandler
+{
+	GENERATED_BODY()
+
+public:
+	UPROPERTY(meta=(Description="Material or MaterialInstance name or package path"))
+	FString Material;
+
+	virtual FString GetDescription() const override
+	{
+		return TEXT("Get detailed info about a material or material instance, including parameters, usage flags, and referenced textures.");
+	}
+
+	virtual void Handle(const FJsonObject* Json, FStringBuilderBase& Result) override
+	{
+		MCPAssets<UMaterialInterface> Assets;
+		Assets.NoScans();
+		Assets.Scan<UMaterial>();
+		Assets.Scan<UMaterialInstanceConstant>();
+		if (!Assets.Exact(Material).Errors(Result).ENone().ETwo().Load()) return;
+		UMaterialInterface* LoadedObj = Assets.Object();
+
+		if (UMaterial* Mat = Cast<UMaterial>(LoadedObj))
+		{
+			EmitMaterial(Mat, Result);
+			return;
+		}
+
+		if (UMaterialInstanceConstant* MI = Cast<UMaterialInstanceConstant>(LoadedObj))
+		{
+			EmitMaterialInstance(MI, Result);
+			return;
+		}
+
+		Result.Appendf(TEXT("ERROR: Loaded object is %s, expected Material or MaterialInstance.\n"),
+			*LoadedObj->GetClass()->GetName());
+	}
+
+private:
+	void EmitMaterial(UMaterial* Mat, FStringBuilderBase& Result)
+	{
+		Result.Appendf(TEXT("Material: %s\n"), *MCPUtils::FormatName(Mat));
+		Result.Appendf(TEXT("Domain: %s\n"), *MCPUtils::EnumToString(Mat->MaterialDomain, TEXT("MD_")));
+		Result.Appendf(TEXT("BlendMode: %s\n"), *MCPUtils::EnumToString(Mat->BlendMode, TEXT("BLEND_")));
+		Result.Appendf(TEXT("TwoSided: %s\n"), Mat->IsTwoSided() ? TEXT("true") : TEXT("false"));
+
+		// Shading models
+		FMaterialShadingModelField SMField = Mat->GetShadingModels();
+		const UEnum* SMEnum = StaticEnum<EMaterialShadingModel>();
+		TArray<FString> SMNames;
+		for (int32 i = 0; i < SMEnum->NumEnums() - 1; ++i)
+		{
+			EMaterialShadingModel SM = (EMaterialShadingModel)SMEnum->GetValueByIndex(i);
+			if (SMField.HasShadingModel(SM))
+				SMNames.Add(SMEnum->GetNameStringByIndex(i));
+		}
+		Result.Appendf(TEXT("ShadingModels: %s\n"), *FString::Join(SMNames, TEXT(", ")));
+
+		// Parameters
+		auto Expressions = Mat->GetExpressions();
+		bool bHasParams = false;
+		for (UMaterialExpression* Expr : Expressions)
+		{
+			if (!Expr) continue;
+
+			if (auto* SP = Cast<UMaterialExpressionScalarParameter>(Expr))
+			{
+				if (!bHasParams) { Result.Append(TEXT("\nParameters:\n")); bHasParams = true; }
+				Result.Appendf(TEXT("  Scalar \"%s\" = %g"), *SP->ParameterName.ToString(), SP->DefaultValue);
+				if (!SP->Group.IsNone()) Result.Appendf(TEXT("  [%s]"), *SP->Group.ToString());
+				Result.Append(TEXT("\n"));
+			}
+			else if (auto* VP = Cast<UMaterialExpressionVectorParameter>(Expr))
+			{
+				if (!bHasParams) { Result.Append(TEXT("\nParameters:\n")); bHasParams = true; }
+				Result.Appendf(TEXT("  Vector \"%s\" = (%.3f, %.3f, %.3f, %.3f)"),
+					*VP->ParameterName.ToString(),
+					VP->DefaultValue.R, VP->DefaultValue.G, VP->DefaultValue.B, VP->DefaultValue.A);
+				if (!VP->Group.IsNone()) Result.Appendf(TEXT("  [%s]"), *VP->Group.ToString());
+				Result.Append(TEXT("\n"));
+			}
+			else if (auto* TP = Cast<UMaterialExpressionTextureSampleParameter2D>(Expr))
+			{
+				if (!bHasParams) { Result.Append(TEXT("\nParameters:\n")); bHasParams = true; }
+				Result.Appendf(TEXT("  Texture \"%s\" = %s"),
+					*TP->ParameterName.ToString(),
+					TP->Texture ? *MCPUtils::FormatName(TP->Texture) : TEXT("None"));
+				if (!TP->Group.IsNone()) Result.Appendf(TEXT("  [%s]"), *TP->Group.ToString());
+				Result.Append(TEXT("\n"));
+			}
+			else if (auto* SSP = Cast<UMaterialExpressionStaticSwitchParameter>(Expr))
+			{
+				if (!bHasParams) { Result.Append(TEXT("\nParameters:\n")); bHasParams = true; }
+				Result.Appendf(TEXT("  StaticSwitch \"%s\" = %s"),
+					*SSP->ParameterName.ToString(),
+					SSP->DefaultValue ? TEXT("true") : TEXT("false"));
+				if (!SSP->Group.IsNone()) Result.Appendf(TEXT("  [%s]"), *SSP->Group.ToString());
+				Result.Append(TEXT("\n"));
+			}
+		}
+
+		// Referenced textures
+		auto RefTexObjs = Mat->GetReferencedTextures();
+		bool bHasTextures = false;
+		for (const TObjectPtr<UObject>& TexObj : RefTexObjs)
+		{
+			if (!TexObj) continue;
+			if (!bHasTextures) { Result.Append(TEXT("\nReferenced Textures:\n")); bHasTextures = true; }
+			if (UTexture* Tex = Cast<UTexture>(TexObj.Get()))
+				Result.Appendf(TEXT("  %s\n"), *MCPUtils::FormatName(Tex));
+			else
+				Result.Appendf(TEXT("  %s\n"), *TexObj->GetPathName());
+		}
+
+		// Usage flags — only print enabled ones
+		Result.Append(TEXT("\nUsage Flags:"));
+		bool bAnyUsage = false;
+		auto EmitFlag = [&](bool bSet, const TCHAR* Name) {
+			if (bSet) { Result.Appendf(TEXT(" %s"), Name); bAnyUsage = true; }
+		};
+		EmitFlag(Mat->bUsedWithSkeletalMesh, TEXT("SkeletalMesh"));
+		EmitFlag(Mat->bUsedWithMorphTargets, TEXT("MorphTargets"));
+		EmitFlag(Mat->bUsedWithNiagaraSprites, TEXT("NiagaraSprites"));
+		EmitFlag(Mat->bUsedWithParticleSprites, TEXT("ParticleSprites"));
+		EmitFlag(Mat->bUsedWithStaticLighting, TEXT("StaticLighting"));
+		if (!bAnyUsage) Result.Append(TEXT(" (none)"));
+		Result.Append(TEXT("\n"));
+
+		// Stats
+		Result.Appendf(TEXT("Expressions: %d\n"), Expressions.Num());
+		int32 TextureSampleCount = 0;
+		for (UMaterialExpression* Expr : Expressions)
+			if (Expr && Expr->IsA<UMaterialExpressionTextureSample>())
+				TextureSampleCount++;
+		Result.Appendf(TEXT("TextureSamples: %d\n"), TextureSampleCount);
+		if (Mat->MaterialGraph)
+			Result.Appendf(TEXT("GraphNodes: %d\n"), Mat->MaterialGraph->Nodes.Num());
+
+		// Additional settings — only print non-default values
+		if (Mat->OpacityMaskClipValue != 0.3333f)
+			Result.Appendf(TEXT("OpacityMaskClipValue: %g\n"), Mat->OpacityMaskClipValue);
+		if (Mat->DitheredLODTransition)
+			Result.Append(TEXT("DitheredLODTransition: true\n"));
+		if (Mat->bAllowNegativeEmissiveColor)
+			Result.Append(TEXT("AllowNegativeEmissiveColor: true\n"));
+	}
+
+	void EmitMaterialInstance(UMaterialInstanceConstant* MI, FStringBuilderBase& Result)
+	{
+		Result.Appendf(TEXT("MaterialInstance: %s\n"), *MCPUtils::FormatName(MI));
+		if (MI->Parent)
+		{
+			if (UMaterial* ParentMat = Cast<UMaterial>(MI->Parent))
+				Result.Appendf(TEXT("Parent: %s\n"), *MCPUtils::FormatName(ParentMat));
+			else if (UMaterialInstance* ParentMI = Cast<UMaterialInstance>(MI->Parent))
+				Result.Appendf(TEXT("Parent: %s\n"), *MCPUtils::FormatName(ParentMI));
+			else
+				Result.Appendf(TEXT("Parent: %s\n"), *MI->Parent->GetPathName());
+		}
+
+		// Overridden parameters
+		bool bHasParams = false;
+		auto EnsureHeader = [&]() {
+			if (!bHasParams) { Result.Append(TEXT("\nOverridden Parameters:\n")); bHasParams = true; }
+		};
+
+		for (const FScalarParameterValue& P : MI->ScalarParameterValues)
+		{
+			EnsureHeader();
+			Result.Appendf(TEXT("  Scalar \"%s\" = %g\n"), *P.ParameterInfo.Name.ToString(), P.ParameterValue);
+		}
+
+		for (const FVectorParameterValue& P : MI->VectorParameterValues)
+		{
+			EnsureHeader();
+			Result.Appendf(TEXT("  Vector \"%s\" = (%.3f, %.3f, %.3f, %.3f)\n"),
+				*P.ParameterInfo.Name.ToString(),
+				P.ParameterValue.R, P.ParameterValue.G, P.ParameterValue.B, P.ParameterValue.A);
+		}
+
+		for (const FTextureParameterValue& P : MI->TextureParameterValues)
+		{
+			EnsureHeader();
+			if (P.ParameterValue)
+			{
+				Result.Appendf(TEXT("  Texture \"%s\" = %s\n"),
+					*P.ParameterInfo.Name.ToString(), *MCPUtils::FormatName(P.ParameterValue));
+			}
+			else
+			{
+				Result.Appendf(TEXT("  Texture \"%s\" = None\n"), *P.ParameterInfo.Name.ToString());
+			}
+		}
+
+		for (const FStaticSwitchParameter& P : MI->GetStaticParameters().StaticSwitchParameters)
+		{
+			EnsureHeader();
+			Result.Appendf(TEXT("  StaticSwitch \"%s\" = %s%s\n"),
+				*P.ParameterInfo.Name.ToString(),
+				P.Value ? TEXT("true") : TEXT("false"),
+				P.bOverride ? TEXT("") : TEXT(" (not overridden)"));
+		}
+	}
+};
--- a/Plugins/BlueprintMCP/Deprecated/UMCPHandler_DumpMaterialFunction.h
+++ b/Plugins/BlueprintMCP/Deprecated/UMCPHandler_DumpMaterialFunction.h
@@ -0,0 +1,147 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "MCPHandler.h"
+#include "MCPAssetFinder.h"
+#include "MCPUtils.h"
+#include "Materials/MaterialFunction.h"
+#include "Materials/MaterialExpression.h"
+#include "Materials/MaterialExpressionFunctionInput.h"
+#include "Materials/MaterialExpressionFunctionOutput.h"
+#include "Materials/MaterialExpressionMaterialFunctionCall.h"
+#include "Materials/MaterialExpressionScalarParameter.h"
+#include "Materials/MaterialExpressionVectorParameter.h"
+#include "Materials/MaterialExpressionTextureSampleParameter2D.h"
+#include "Materials/MaterialExpressionStaticSwitchParameter.h"
+#include "Materials/MaterialExpressionConstant.h"
+#include "Materials/MaterialExpressionConstant3Vector.h"
+#include "Materials/MaterialExpressionConstant4Vector.h"
+#include "Materials/MaterialExpressionTextureObjectParameter.h"
+#include "Materials/MaterialExpressionTextureSample.h"
+#include "Materials/MaterialExpressionTextureCoordinate.h"
+#include "Materials/MaterialExpressionComponentMask.h"
+#include "Materials/MaterialExpressionCustom.h"
+#include "Engine/Texture.h"
+#include "UMCPHandler_DumpMaterialFunction.generated.h"
+
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+
+UCLASS(meta=(Group="Unclassified"))
+class UMCPHandler_DumpMaterialFunction : public UObject, public IMCPHandler
+{
+	GENERATED_BODY()
+
+public:
+	UPROPERTY(meta=(Description="MaterialFunction name or package path"))
+	FString MaterialFunction;
+
+	virtual FString GetDescription() const override
+	{
+		return TEXT("Get detailed info about a material function, including its inputs, outputs, and expressions.");
+	}
+
+	virtual void Handle(const FJsonObject* Json, FStringBuilderBase& Result) override
+	{
+		MCPAssets<UMaterialFunction> Assets;
+		if (!Assets.Exact(MaterialFunction).Errors(Result).ENone().ETwo().Load()) return;
+		UMaterialFunction* MF = Assets.Object();
+
+		Result.Appendf(TEXT("MaterialFunction: %s\n"), *MCPUtils::FormatName(MF));
+
+		FString Desc = MF->GetDescription();
+		if (!Desc.IsEmpty())
+			Result.Appendf(TEXT("Description: %s\n"), *Desc);
+
+		auto Expressions = MF->GetExpressions();
+		Result.Appendf(TEXT("Expressions: %d\n"), Expressions.Num());
+
+		// Inputs and outputs
+		bool bHasInputs = false;
+		bool bHasOutputs = false;
+		for (UMaterialExpression* Expr : Expressions)
+		{
+			if (!Expr) continue;
+			if (auto* FI = Cast<UMaterialExpressionFunctionInput>(Expr))
+			{
+				if (!bHasInputs) { Result.Append(TEXT("\nInputs:\n")); bHasInputs = true; }
+				Result.Appendf(TEXT("  %s\n"), *MCPUtils::FormatName(Expr));
+			}
+			else if (auto* FO = Cast<UMaterialExpressionFunctionOutput>(Expr))
+			{
+				if (!bHasOutputs) { Result.Append(TEXT("\nOutputs:\n")); bHasOutputs = true; }
+				Result.Appendf(TEXT("  %s\n"), *MCPUtils::FormatName(Expr));
+			}
+		}
+
+		// All expressions
+		Result.Append(TEXT("\nExpression List:\n"));
+		for (UMaterialExpression* Expr : Expressions)
+		{
+			if (!Expr) continue;
+			Result.Appendf(TEXT("  %s"), *MCPUtils::FormatName(Expr));
+			EmitExpressionDetails(Expr, Result);
+			Result.Append(TEXT("\n"));
+		}
+	}
+
+private:
+	void EmitExpressionDetails(UMaterialExpression* Expr, FStringBuilderBase& Result)
+	{
+		if (auto* SP = Cast<UMaterialExpressionScalarParameter>(Expr))
+		{
+			Result.Appendf(TEXT("  default=%g"), SP->DefaultValue);
+			if (!SP->Group.IsNone()) Result.Appendf(TEXT("  [%s]"), *SP->Group.ToString());
+		}
+		else if (auto* VP = Cast<UMaterialExpressionVectorParameter>(Expr))
+		{
+			Result.Appendf(TEXT("  default=(%.3f, %.3f, %.3f, %.3f)"),
+				VP->DefaultValue.R, VP->DefaultValue.G, VP->DefaultValue.B, VP->DefaultValue.A);
+			if (!VP->Group.IsNone()) Result.Appendf(TEXT("  [%s]"), *VP->Group.ToString());
+		}
+		else if (auto* TP = Cast<UMaterialExpressionTextureSampleParameter2D>(Expr))
+		{
+			Result.Appendf(TEXT("  texture=%s"),
+				TP->Texture ? *MCPUtils::FormatName(TP->Texture) : TEXT("None"));
+			if (!TP->Group.IsNone()) Result.Appendf(TEXT("  [%s]"), *TP->Group.ToString());
+		}
+		else if (auto* SSP = Cast<UMaterialExpressionStaticSwitchParameter>(Expr))
+		{
+			Result.Appendf(TEXT("  default=%s"), SSP->DefaultValue ? TEXT("true") : TEXT("false"));
+			if (!SSP->Group.IsNone()) Result.Appendf(TEXT("  [%s]"), *SSP->Group.ToString());
+		}
+		else if (auto* SC = Cast<UMaterialExpressionConstant>(Expr))
+		{
+			Result.Appendf(TEXT("  value=%g"), SC->R);
+		}
+		else if (auto* C3 = Cast<UMaterialExpressionConstant3Vector>(Expr))
+		{
+			Result.Appendf(TEXT("  value=(%.3f, %.3f, %.3f)"), C3->Constant.R, C3->Constant.G, C3->Constant.B);
+		}
+		else if (auto* C4 = Cast<UMaterialExpressionConstant4Vector>(Expr))
+		{
+			Result.Appendf(TEXT("  value=(%.3f, %.3f, %.3f, %.3f)"),
+				C4->Constant.R, C4->Constant.G, C4->Constant.B, C4->Constant.A);
+		}
+		else if (auto* FC = Cast<UMaterialExpressionMaterialFunctionCall>(Expr))
+		{
+			if (FC->MaterialFunction)
+				Result.Appendf(TEXT("  calls=%s"), *FC->MaterialFunction->GetPathName());
+		}
+		else if (auto* TS = Cast<UMaterialExpressionTextureSample>(Expr))
+		{
+			if (TS->Texture)
+				Result.Appendf(TEXT("  texture=%s"), *MCPUtils::FormatName(TS->Texture));
+		}
+		else if (auto* TC = Cast<UMaterialExpressionTextureCoordinate>(Expr))
+		{
+			Result.Appendf(TEXT("  index=%d tiling=(%.1f, %.1f)"), TC->CoordinateIndex, TC->UTiling, TC->VTiling);
+		}
+		else if (auto* Custom = Cast<UMaterialExpressionCustom>(Expr))
+		{
+			Result.Appendf(TEXT("  code_len=%d"), Custom->Code.Len());
+		}
+	}
+};
--- a/Plugins/BlueprintMCP/Deprecated/UMCPHandler_RemoveStructField.h
+++ b/Plugins/BlueprintMCP/Deprecated/UMCPHandler_RemoveStructField.h
@@ -0,0 +1,75 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "MCPHandler.h"
+#include "MCPFetcher.h"
+#include "MCPUtils.h"
+#include "StructUtils/UserDefinedStruct.h"
+#include "UserDefinedStructure/UserDefinedStructEditorData.h"
+#include "UMCPHandler_RemoveStructField.generated.h"
+
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+
+UCLASS(meta=(Group="Unclassified"))
+class UMCPHandler_RemoveStructField : public UObject, public IMCPHandler
+{
+	GENERATED_BODY()
+
+public:
+	UPROPERTY(meta=(Description="Struct name or package path"))
+	FString Struct;
+
+	UPROPERTY(meta=(Description="Name of the field to remove"))
+	FString FieldName;
+
+	virtual FString GetDescription() const override
+	{
+		return TEXT("Remove a field from a UserDefinedStruct asset.");
+	}
+
+	virtual void Handle(const FJsonObject* Json, FStringBuilderBase& Result) override
+	{
+		MCPFetcher F(Result);
+		UUserDefinedStruct* S = F.Walk(Struct).Cast<UUserDefinedStruct>();
+		if (!S) return;
+
+		// Find the field GUID by name
+		FGuid TargetGuid;
+		bool bFound = false;
+		for (const FStructVariableDescription& Var : FStructureEditorUtils::GetVarDesc(S))
+		{
+			if (Var.FriendlyName.Equals(FieldName, ESearchCase::IgnoreCase) ||
+				Var.VarName.ToString().Equals(FieldName, ESearchCase::IgnoreCase))
+			{
+				TargetGuid = Var.VarGuid;
+				bFound = true;
+				break;
+			}
+		}
+
+		if (!bFound)
+		{
+			Result.Appendf(TEXT("ERROR: Field '%s' not found in %s.\nAvailable fields:\n"),
+				*FieldName, *MCPUtils::FormatName(S));
+			for (const FStructVariableDescription& Var : FStructureEditorUtils::GetVarDesc(S))
+			{
+				Result.Appendf(TEXT("  %s\n"), *Var.FriendlyName);
+			}
+			return;
+		}
+
+		if (!FStructureEditorUtils::RemoveVariable(S, TargetGuid))
+		{
+			Result.Appendf(TEXT("ERROR: Failed to remove field '%s'."), *FieldName);
+			return;
+		}
+
+		bool bSaved = MCPUtils::SaveGenericPackage(S);
+		Result.Appendf(TEXT("Removed field %s from %s.%s\n"),
+			*FieldName, *MCPUtils::FormatName(S),
+			bSaved ? TEXT("") : TEXT(" WARNING: save failed."));
+	}
+};
--- a/Plugins/BlueprintMCP/Deprecated/UMCPHandler_SearchWithinMaterials.h
+++ b/Plugins/BlueprintMCP/Deprecated/UMCPHandler_SearchWithinMaterials.h
@@ -0,0 +1,106 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "MCPHandler.h"
+#include "MCPAssetFinder.h"
+#include "MCPUtils.h"
+#include "Materials/Material.h"
+#include "Materials/MaterialExpression.h"
+#include "Materials/MaterialExpressionScalarParameter.h"
+#include "Materials/MaterialExpressionVectorParameter.h"
+#include "Materials/MaterialExpressionTextureSampleParameter2D.h"
+#include "Materials/MaterialExpressionStaticSwitchParameter.h"
+#include "UMCPHandler_SearchWithinMaterials.generated.h"
+
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+
+UCLASS(meta=(Group="Unclassified"))
+class UMCPHandler_SearchWithinMaterials : public UObject, public IMCPHandler
+{
+	GENERATED_BODY()
+
+public:
+	UPROPERTY(meta=(Description="Search query string to match against material names, expression classes, and parameter names"))
+	FString Query;
+
+	UPROPERTY(meta=(Optional, Description="Maximum number of results to return (default 50, max 200)"))
+	int32 MaxResults = 50;
+
+	virtual FString GetDescription() const override
+	{
+		return TEXT("Search across all materials for matching material names, expression types, and parameter names.");
+	}
+
+	virtual void Handle(const FJsonObject* Json, FStringBuilderBase& Result) override
+	{
+		FString DecodedQuery = MCPUtils::UrlDecode(Query);
+		MaxResults = FMath::Clamp(MaxResults, 1, 200);
+
+		int32 Count = 0;
+
+		MCPAssets<UMaterial> AllMaterials;
+		AllMaterials.Load();
+
+		for (UMaterial* MaterialObj : AllMaterials.Objects())
+		{
+			if (Count >= MaxResults) break;
+			if (!MaterialObj) continue;
+
+			FString MatName = MCPUtils::FormatName(MaterialObj);
+
+			// Check material name
+			bool bNameMatch = MatName.Contains(DecodedQuery, ESearchCase::IgnoreCase);
+
+			if (bNameMatch)
+			{
+				Result.Appendf(TEXT("material %s\n"), *MatName);
+				Count++;
+			}
+
+			// Search expressions
+			for (UMaterialExpression* Expr : MaterialObj->GetExpressions())
+			{
+				if (!Expr || Count >= MaxResults) continue;
+
+				FString ExprName = MCPUtils::FormatName(Expr);
+				FString ExprClass = Expr->GetClass()->GetName();
+				FString ExprDesc = Expr->GetDescription();
+
+				// Check parameter name
+				FString ParamName;
+				if (auto* SP = Cast<UMaterialExpressionScalarParameter>(Expr))
+					ParamName = SP->ParameterName.ToString();
+				else if (auto* VP = Cast<UMaterialExpressionVectorParameter>(Expr))
+					ParamName = VP->ParameterName.ToString();
+				else if (auto* TP = Cast<UMaterialExpressionTextureSampleParameter2D>(Expr))
+					ParamName = TP->ParameterName.ToString();
+				else if (auto* SSP = Cast<UMaterialExpressionStaticSwitchParameter>(Expr))
+					ParamName = SSP->ParameterName.ToString();
+
+				bool bExprMatch = ExprDesc.Contains(DecodedQuery, ESearchCase::IgnoreCase) ||
+					ExprClass.Contains(DecodedQuery, ESearchCase::IgnoreCase) ||
+					(!ParamName.IsEmpty() && ParamName.Contains(DecodedQuery, ESearchCase::IgnoreCase));
+
+				if (!bExprMatch) continue;
+
+				Result.Appendf(TEXT("expression %s in %s (%s)"), *ExprName, *MatName, *ExprClass);
+				if (!ParamName.IsEmpty())
+					Result.Appendf(TEXT(" param=%s"), *ParamName);
+				Result.Append(TEXT("\n"));
+				Count++;
+			}
+		}
+
+		if (Count == 0)
+		{
+			Result.Append(TEXT("No matches found.\n"));
+		}
+		else if (Count >= MaxResults)
+		{
+			Result.Appendf(TEXT("WARNING: Reached limit of %d results. Specify MaxResults to raise it.\n"), MaxResults);
+		}
+	}
+};
--- a/Plugins/BlueprintMCP/Deprecated/UMCPHandler_SetMaterialExpressionPosition.h
+++ b/Plugins/BlueprintMCP/Deprecated/UMCPHandler_SetMaterialExpressionPosition.h
@@ -0,0 +1,132 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "MCPHandler.h"
+#include "MCPAssetFinder.h"
+#include "MCPFetcher.h"
+#include "MCPUtils.h"
+#include "Materials/Material.h"
+#include "Materials/MaterialExpression.h"
+#include "Materials/MaterialFunction.h"
+#include "MaterialGraph/MaterialGraph.h"
+#include "MaterialGraph/MaterialGraphNode.h"
+#include "UMCPHandler_SetMaterialExpressionPosition.generated.h"
+
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+
+UCLASS(meta=(Group="Unclassified"))
+class UMCPHandler_SetMaterialExpressionPosition : public UObject, public IMCPHandler
+{
+	GENERATED_BODY()
+
+public:
+	UPROPERTY(meta=(Optional, Description="Material name or package path (specify this or materialFunction)"))
+	FString Material;
+
+	UPROPERTY(meta=(Optional, Description="Material function name or package path (specify this or material)"))
+	FString MaterialFunction;
+
+	UPROPERTY(meta=(Description="Expression name (use FormatName from DumpMaterial output)"))
+	FString Node;
+
+	UPROPERTY(meta=(Description="New X position"))
+	int32 PosX = 0;
+
+	UPROPERTY(meta=(Description="New Y position"))
+	int32 PosY = 0;
+
+	UPROPERTY(meta=(Optional, Description="If true, preview the change without applying it"))
+	bool DryRun = false;
+
+	virtual FString GetDescription() const override
+	{
+		return TEXT("Reposition a material expression node in the material graph editor.");
+	}
+
+	virtual void Handle(const FJsonObject* Json, FStringBuilderBase& Result) override
+	{
+		if (Material.IsEmpty() && MaterialFunction.IsEmpty())
+		{
+			MCPErrorCallback(Result).SetError(TEXT("Specify 'material' or 'materialFunction'."));
+			return;
+		}
+
+		// Load material or material function
+		UMaterial* MaterialObj = nullptr;
+		UMaterialFunction* MatFunc = nullptr;
+
+		if (!MaterialFunction.IsEmpty())
+		{
+			MCPAssets<UMaterialFunction> MFAssets;
+			if (!MFAssets.Exact(MaterialFunction).Errors(Result).ENone().ETwo().Load()) return;
+			MatFunc = MFAssets.Object();
+		}
+		else
+		{
+			MCPAssets<UMaterial> MatAssets;
+			if (!MatAssets.Exact(Material).Errors(Result).ENone().ETwo().Load()) return;
+			MaterialObj = MatAssets.Object();
+		}
+
+		if (MaterialObj) MCPUtils::EnsureMaterialGraph(MaterialObj);
+		UEdGraph* Graph = MaterialObj ? (UEdGraph*)MaterialObj->MaterialGraph : (MatFunc ? MatFunc->MaterialGraph : nullptr);
+		if (!Graph)
+		{
+			MCPErrorCallback(Result).SetError(TEXT("Asset has no material graph."));
+			return;
+		}
+
+		// Find node by name
+		UMaterialGraphNode* TargetMatNode = nullptr;
+		for (UEdGraphNode* GraphNode : Graph->Nodes)
+		{
+			if (!GraphNode) continue;
+			UMaterialGraphNode* MatNode = Cast<UMaterialGraphNode>(GraphNode);
+			if (!MatNode || !MatNode->MaterialExpression) continue;
+			if (MCPUtils::Identifies(Node, MatNode->MaterialExpression))
+			{
+				TargetMatNode = MatNode;
+				break;
+			}
+		}
+
+		if (!TargetMatNode)
+		{
+			MCPErrorCallback(Result).SetError(FString::Printf(TEXT("Expression '%s' not found."), *Node));
+			return;
+		}
+
+		if (DryRun)
+		{
+			Result.Appendf(TEXT("DryRun: would move %s to (%d, %d)\n"),
+				*MCPUtils::FormatName(TargetMatNode->MaterialExpression), PosX, PosY);
+			return;
+		}
+
+		// Set position on the graph node
+		TargetMatNode->NodePosX = PosX;
+		TargetMatNode->NodePosY = PosY;
+
+		// Also update the underlying expression position
+		if (TargetMatNode->MaterialExpression)
+		{
+			TargetMatNode->MaterialExpression->MaterialExpressionEditorX = PosX;
+			TargetMatNode->MaterialExpression->MaterialExpressionEditorY = PosY;
+		}
+
+		UObject* Asset = MaterialObj ? (UObject*)MaterialObj : (UObject*)MatFunc;
+		Asset->PreEditChange(nullptr);
+		Asset->PostEditChange();
+
+		// Save
+		bool bSaved = MaterialObj ? MCPUtils::SaveMaterialPackage(MaterialObj) : MCPUtils::SaveGenericPackage(MatFunc);
+
+		Result.Appendf(TEXT("Moved %s to (%d, %d)"),
+			*MCPUtils::FormatName(TargetMatNode->MaterialExpression), PosX, PosY);
+		if (!bSaved) Result.Append(TEXT(" (save failed)"));
+		Result.Append(TEXT("\n"));
+	}
+};
--- a/Plugins/BlueprintMCP/Deprecated/UMCPHandler_SetMaterialExpressionProperty.h
+++ b/Plugins/BlueprintMCP/Deprecated/UMCPHandler_SetMaterialExpressionProperty.h
@@ -0,0 +1,282 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "MCPHandler.h"
+#include "MCPAssetFinder.h"
+#include "MCPFetcher.h"
+#include "MCPUtils.h"
+#include "Materials/Material.h"
+#include "Materials/MaterialFunction.h"
+#include "Materials/MaterialExpression.h"
+#include "Materials/MaterialExpressionScalarParameter.h"
+#include "Materials/MaterialExpressionVectorParameter.h"
+#include "Materials/MaterialExpressionConstant.h"
+#include "Materials/MaterialExpressionConstant3Vector.h"
+#include "Materials/MaterialExpressionConstant4Vector.h"
+#include "Materials/MaterialExpressionTextureSample.h"
+#include "Materials/MaterialExpressionTextureCoordinate.h"
+#include "Materials/MaterialExpressionComponentMask.h"
+#include "Materials/MaterialExpressionCustom.h"
+#include "MaterialGraph/MaterialGraph.h"
+#include "MaterialGraph/MaterialGraphNode.h"
+#include "UMCPHandler_SetMaterialExpressionProperty.generated.h"
+
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+
+UCLASS(meta=(Group="Unclassified"))
+class UMCPHandler_SetMaterialExpressionProperty : public UObject, public IMCPHandler
+{
+	GENERATED_BODY()
+
+public:
+	UPROPERTY(meta=(Optional, Description="Material name or package path (specify this or materialFunction)"))
+	FString Material;
+
+	UPROPERTY(meta=(Optional, Description="Material function name or package path (specify this or material)"))
+	FString MaterialFunction;
+
+	UPROPERTY(meta=(Description="Expression node name (from FormatName)"))
+	FString Node;
+
+	virtual FString GetDescription() const override
+	{
+		return TEXT("Set the value or properties on a material expression node. "
+			"The 'value' field in the JSON payload provides the new value, whose format depends on the expression type.");
+	}
+
+	virtual void Handle(const FJsonObject* Json, FStringBuilderBase& Result) override
+	{
+		if (Material.IsEmpty() && MaterialFunction.IsEmpty())
+		{
+			Result.Append(TEXT("ERROR: Specify 'material' or 'materialFunction'\n"));
+			return;
+		}
+
+		if (!Json->HasField(TEXT("value")))
+		{
+			Result.Append(TEXT("ERROR: Missing required field: value\n"));
+			return;
+		}
+
+		// Load material or material function
+		UMaterial* MaterialObj = nullptr;
+		UMaterialFunction* MatFunc = nullptr;
+
+		if (!MaterialFunction.IsEmpty())
+		{
+			MCPAssets<UMaterialFunction> MFAssets;
+			if (!MFAssets.Exact(MaterialFunction).Errors(Result).ENone().ETwo().Load()) return;
+			MatFunc = MFAssets.Object();
+		}
+		else
+		{
+			MCPAssets<UMaterial> MatAssets;
+			if (!MatAssets.Exact(Material).Errors(Result).ENone().ETwo().Load()) return;
+			MaterialObj = MatAssets.Object();
+		}
+
+		if (MaterialObj) MCPUtils::EnsureMaterialGraph(MaterialObj);
+		UEdGraph* Graph = MaterialObj ? (UEdGraph*)MaterialObj->MaterialGraph : (MatFunc ? MatFunc->MaterialGraph : nullptr);
+		if (!Graph)
+		{
+			Result.Appendf(TEXT("ERROR: No material graph found\n"));
+			return;
+		}
+
+		// Find the node by name using Identifies
+		UMaterialGraphNode* TargetMatNode = nullptr;
+		for (UEdGraphNode* GraphNode : Graph->Nodes)
+		{
+			if (!GraphNode) continue;
+			if (!MCPUtils::Identifies(Node, GraphNode)) continue;
+			TargetMatNode = Cast<UMaterialGraphNode>(GraphNode);
+			if (TargetMatNode) break;
+		}
+
+		if (!TargetMatNode)
+		{
+			Result.Appendf(TEXT("ERROR: Node '%s' not found in material graph\n"), *Node);
+			return;
+		}
+
+		UMaterialExpression* Expr = TargetMatNode->MaterialExpression;
+		if (!Expr)
+		{
+			Result.Appendf(TEXT("ERROR: Node '%s' has no material expression\n"), *MCPUtils::FormatName(TargetMatNode));
+			return;
+		}
+
+		UObject* Asset = MaterialObj ? (UObject*)MaterialObj : (UObject*)MatFunc;
+		Asset->PreEditChange(nullptr);
+
+		FString SetResult;
+		if (!ApplyValue(Expr, Json, Result, SetResult))
+		{
+			Asset->PostEditChange();
+			return;
+		}
+
+		Asset->PostEditChange();
+		Asset->MarkPackageDirty();
+
+		bool bSaved = MaterialObj ? MCPUtils::SaveMaterialPackage(MaterialObj) : MCPUtils::SaveGenericPackage(MatFunc);
+
+		Result.Appendf(TEXT("%s = %s"), *MCPUtils::FormatName(Expr), *SetResult);
+		if (!bSaved) Result.Append(TEXT(" (save failed)"));
+		Result.Append(TEXT("\n"));
+	}
+
+private:
+	// Apply the value from JSON to the expression. Returns false on error (with message in Result).
+	// On success, fills SetResult with a human-readable summary of the new value.
+	bool ApplyValue(UMaterialExpression* Expr, const FJsonObject* Json, FStringBuilderBase& Result, FString& SetResult)
+	{
+		if (auto* E = Cast<UMaterialExpressionConstant>(Expr))
+		{
+			double Value = Json->GetNumberField(TEXT("value"));
+			E->R = (float)Value;
+			SetResult = FString::Printf(TEXT("%g"), Value);
+			return true;
+		}
+
+		if (auto* E = Cast<UMaterialExpressionConstant3Vector>(Expr))
+		{
+			FLinearColor C;
+			if (!ParseColorValue(Json, C, false, Result)) return false;
+			E->Constant = C;
+			SetResult = FString::Printf(TEXT("(%.3f, %.3f, %.3f)"), C.R, C.G, C.B);
+			return true;
+		}
+
+		if (auto* E = Cast<UMaterialExpressionConstant4Vector>(Expr))
+		{
+			FLinearColor C;
+			if (!ParseColorValue(Json, C, true, Result)) return false;
+			E->Constant = C;
+			SetResult = FString::Printf(TEXT("(%.3f, %.3f, %.3f, %.3f)"), C.R, C.G, C.B, C.A);
+			return true;
+		}
+
+		if (auto* E = Cast<UMaterialExpressionScalarParameter>(Expr))
+		{
+			double Value = Json->GetNumberField(TEXT("value"));
+			E->DefaultValue = (float)Value;
+			SetResult = FString::Printf(TEXT("%g"), Value);
+			ApplyParameterName(E, Json);
+			return true;
+		}
+
+		if (auto* E = Cast<UMaterialExpressionVectorParameter>(Expr))
+		{
+			FLinearColor C;
+			if (!ParseColorValue(Json, C, true, Result)) return false;
+			E->DefaultValue = C;
+			SetResult = FString::Printf(TEXT("(%.3f, %.3f, %.3f, %.3f)"), C.R, C.G, C.B, C.A);
+			ApplyParameterName(E, Json);
+			return true;
+		}
+
+		if (auto* E = Cast<UMaterialExpressionTextureCoordinate>(Expr))
+		{
+			const TSharedPtr<FJsonObject>* ValueObj = nullptr;
+			if (!Json->TryGetObjectField(TEXT("value"), ValueObj) || !ValueObj || !(*ValueObj).IsValid())
+			{
+				Result.Append(TEXT("ERROR: TextureCoordinate requires value as {coordinateIndex, uTiling, vTiling}\n"));
+				return false;
+			}
+			double CoordIndex = 0, UTiling = 1, VTiling = 1;
+			(*ValueObj)->TryGetNumberField(TEXT("coordinateIndex"), CoordIndex);
+			(*ValueObj)->TryGetNumberField(TEXT("uTiling"), UTiling);
+			(*ValueObj)->TryGetNumberField(TEXT("vTiling"), VTiling);
+			E->CoordinateIndex = (int32)CoordIndex;
+			E->UTiling = (float)UTiling;
+			E->VTiling = (float)VTiling;
+			SetResult = FString::Printf(TEXT("index=%d uTiling=%g vTiling=%g"), (int32)CoordIndex, UTiling, VTiling);
+			return true;
+		}
+
+		if (auto* E = Cast<UMaterialExpressionCustom>(Expr))
+		{
+			FString Code;
+			if (Json->TryGetStringField(TEXT("code"), Code))
+			{
+				E->Code = Code;
+			}
+			else if (Json->HasField(TEXT("value")))
+			{
+				FString ValueStr = Json->GetStringField(TEXT("value"));
+				if (!ValueStr.IsEmpty()) E->Code = ValueStr;
+			}
+			SetResult = FString::Printf(TEXT("code: %d chars"), E->Code.Len());
+
+			FString OutputTypeStr;
+			if (Json->TryGetStringField(TEXT("outputType"), OutputTypeStr) && !OutputTypeStr.IsEmpty())
+			{
+				ECustomMaterialOutputType OutType;
+				if (MCPUtils::StringToEnum(OutputTypeStr, OutType, MCPErrorCallback(Result)))
+					E->OutputType = OutType;
+			}
+			return true;
+		}
+
+		if (auto* E = Cast<UMaterialExpressionComponentMask>(Expr))
+		{
+			const TSharedPtr<FJsonObject>* ValueObj = nullptr;
+			if (!Json->TryGetObjectField(TEXT("value"), ValueObj) || !ValueObj || !(*ValueObj).IsValid())
+			{
+				Result.Append(TEXT("ERROR: ComponentMask requires value as {r, g, b, a} (booleans)\n"));
+				return false;
+			}
+			bool bR = false, bG = false, bB = false, bA = false;
+			(*ValueObj)->TryGetBoolField(TEXT("r"), bR);
+			(*ValueObj)->TryGetBoolField(TEXT("g"), bG);
+			(*ValueObj)->TryGetBoolField(TEXT("b"), bB);
+			(*ValueObj)->TryGetBoolField(TEXT("a"), bA);
+			E->R = bR ? 1 : 0;
+			E->G = bG ? 1 : 0;
+			E->B = bB ? 1 : 0;
+			E->A = bA ? 1 : 0;
+			SetResult = FString::Printf(TEXT("R=%s G=%s B=%s A=%s"),
+				bR ? TEXT("true") : TEXT("false"),
+				bG ? TEXT("true") : TEXT("false"),
+				bB ? TEXT("true") : TEXT("false"),
+				bA ? TEXT("true") : TEXT("false"));
+			return true;
+		}
+
+		Result.Appendf(TEXT("ERROR: Expression type '%s' does not support value setting. Supported: "
+			"Constant, Constant3Vector, Constant4Vector, ScalarParameter, VectorParameter, "
+			"TextureCoordinate, Custom, ComponentMask\n"),
+			*Expr->GetClass()->GetName());
+		return false;
+	}
+
+	// Parse {r, g, b[, a]} from the "value" JSON field.
+	bool ParseColorValue(const FJsonObject* Json, FLinearColor& OutColor, bool bHasAlpha, FStringBuilderBase& Result)
+	{
+		const TSharedPtr<FJsonObject>* ValueObj = nullptr;
+		if (!Json->TryGetObjectField(TEXT("value"), ValueObj) || !ValueObj || !(*ValueObj).IsValid())
+		{
+			Result.Appendf(TEXT("ERROR: requires value as {r, g, b%s}\n"), bHasAlpha ? TEXT(", a") : TEXT(""));
+			return false;
+		}
+		double R = 0, G = 0, B = 0, A = 1;
+		(*ValueObj)->TryGetNumberField(TEXT("r"), R);
+		(*ValueObj)->TryGetNumberField(TEXT("g"), G);
+		(*ValueObj)->TryGetNumberField(TEXT("b"), B);
+		if (bHasAlpha) (*ValueObj)->TryGetNumberField(TEXT("a"), A);
+		OutColor = FLinearColor((float)R, (float)G, (float)B, (float)A);
+		return true;
+	}
+
+	// If the JSON has a "parameterName" field, apply it to a parameter expression.
+	void ApplyParameterName(UMaterialExpressionParameter* Param, const FJsonObject* Json)
+	{
+		FString ParamName;
+		if (Json->TryGetStringField(TEXT("parameterName"), ParamName) && !ParamName.IsEmpty())
+			Param->ParameterName = FName(*ParamName);
+	}
+};