Commit ff17334

@@ -0,0 +1,91 @@
+name: Go
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Go
+      uses: actions/setup-go@v4
+      with:
+        go-version: '1.21'
+
+    - name: Download dependencies
+      run: go mod download
+
+    - name: Run tests
+      run: go test -v ./...
+
+    - name: Run tests with race detector
+      run: go test -race -short ./...
+
+    - name: Run tests with coverage
+      run: go test -coverprofile=coverage.out ./...
+
+    - name: Upload coverage to Codecov
+      uses: codecov/codecov-action@v3
+      with:
+        file: ./coverage.out
+
+  build:
+    runs-on: ubuntu-latest
+    needs: test
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Go
+      uses: actions/setup-go@v4
+      with:
+        go-version: '1.21'
+
+    - name: Build servers
+      run: make build
+
+    - name: Upload artifacts
+      uses: actions/upload-artifact@v3
+      with:
+        name: mcp-servers-linux
+        path: bin/
+
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Go
+      uses: actions/setup-go@v4
+      with:
+        go-version: '1.21'
+
+    - name: golangci-lint
+      uses: golangci/golangci-lint-action@v3
+      with:
+        version: latest
+
+  release:
+    runs-on: ubuntu-latest
+    needs: [test, build, lint]
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Go
+      uses: actions/setup-go@v4
+      with:
+        go-version: '1.21'
+
+    - name: Build release binaries
+      run: make release
+
+    - name: Upload release artifacts
+      uses: actions/upload-artifact@v3
+      with:
+        name: mcp-servers-release
+        path: bin/
\ No newline at end of file

@@ -0,0 +1,35 @@
+package main
+
+import (
+	"context"
+	"log"
+	"os"
+	"path/filepath"
+
+	"github.com/xlgmokha/mcp/pkg/mcp"
+)
+
+func main() {
+	// Default memory file location
+	memoryFile := os.Getenv("MEMORY_FILE")
+	if memoryFile == "" {
+		homeDir, err := os.UserHomeDir()
+		if err != nil {
+			log.Fatalf("Failed to get home directory: %v", err)
+		}
+		memoryFile = filepath.Join(homeDir, ".mcp_memory.json")
+	}
+
+	server := NewMemoryServer(memoryFile)
+	
+	// Set up basic initialization
+	server.SetInitializeHandler(func(req mcp.InitializeRequest) (mcp.InitializeResult, error) {
+		// Use default initialization
+		return mcp.InitializeResult{}, nil
+	})
+	
+	ctx := context.Background()
+	if err := server.Run(ctx); err != nil {
+		log.Fatalf("Server error: %v", err)
+	}
+}
\ No newline at end of file

@@ -0,0 +1,804 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"strings"
+	"sync"
+
+	"github.com/xlgmokha/mcp/pkg/mcp"
+)
+
+// MemoryServer implements the Memory MCP server with knowledge graph functionality
+type MemoryServer struct {
+	*mcp.Server
+	memoryFile string
+	graph      *KnowledgeGraph
+	mu         sync.RWMutex
+}
+
+// KnowledgeGraph represents the in-memory knowledge graph
+type KnowledgeGraph struct {
+	Entities  map[string]*Entity  `json:"entities"`
+	Relations map[string]Relation `json:"relations"`
+}
+
+// Entity represents an entity in the knowledge graph
+type Entity struct {
+	Name         string   `json:"name"`
+	EntityType   string   `json:"entityType"`
+	Observations []string `json:"observations"`
+}
+
+// Relation represents a relationship between entities
+type Relation struct {
+	From         string `json:"from"`
+	To           string `json:"to"`
+	RelationType string `json:"relationType"`
+}
+
+// NewMemoryServer creates a new Memory MCP server
+func NewMemoryServer(memoryFile string) *MemoryServer {
+	server := mcp.NewServer("mcp-memory", "1.0.0")
+
+	memoryServer := &MemoryServer{
+		Server:     server,
+		memoryFile: memoryFile,
+		graph: &KnowledgeGraph{
+			Entities:  make(map[string]*Entity),
+			Relations: make(map[string]Relation),
+		},
+	}
+
+	// Load existing data
+	memoryServer.loadGraph()
+
+	// Register all memory tools
+	memoryServer.registerTools()
+
+	return memoryServer
+}
+
+// registerTools registers all Memory tools with the server
+func (ms *MemoryServer) registerTools() {
+	ms.RegisterTool("create_entities", ms.HandleCreateEntities)
+	ms.RegisterTool("create_relations", ms.HandleCreateRelations)
+	ms.RegisterTool("add_observations", ms.HandleAddObservations)
+	ms.RegisterTool("delete_entities", ms.HandleDeleteEntities)
+	ms.RegisterTool("delete_observations", ms.HandleDeleteObservations)
+	ms.RegisterTool("delete_relations", ms.HandleDeleteRelations)
+	ms.RegisterTool("read_graph", ms.HandleReadGraph)
+	ms.RegisterTool("search_nodes", ms.HandleSearchNodes)
+	ms.RegisterTool("open_nodes", ms.HandleOpenNodes)
+}
+
+// ListTools returns all available Memory tools
+func (ms *MemoryServer) ListTools() []mcp.Tool {
+	return []mcp.Tool{
+		{
+			Name:        "create_entities",
+			Description: "Create multiple new entities in the knowledge graph",
+			InputSchema: map[string]interface{}{
+				"type": "object",
+				"properties": map[string]interface{}{
+					"entities": map[string]interface{}{
+						"type": "array",
+						"items": map[string]interface{}{
+							"type": "object",
+							"properties": map[string]interface{}{
+								"name": map[string]interface{}{
+									"type":        "string",
+									"description": "The name of the entity",
+								},
+								"entityType": map[string]interface{}{
+									"type":        "string",
+									"description": "The type of the entity",
+								},
+								"observations": map[string]interface{}{
+									"type": "array",
+									"items": map[string]interface{}{
+										"type": "string",
+									},
+									"description": "An array of observation contents associated with the entity",
+								},
+							},
+							"required": []string{"name", "entityType", "observations"},
+						},
+					},
+				},
+				"required": []string{"entities"},
+			},
+		},
+		{
+			Name:        "create_relations",
+			Description: "Create multiple new relations between entities in the knowledge graph. Relations should be in active voice",
+			InputSchema: map[string]interface{}{
+				"type": "object",
+				"properties": map[string]interface{}{
+					"relations": map[string]interface{}{
+						"type": "array",
+						"items": map[string]interface{}{
+							"type": "object",
+							"properties": map[string]interface{}{
+								"from": map[string]interface{}{
+									"type":        "string",
+									"description": "The name of the entity where the relation starts",
+								},
+								"to": map[string]interface{}{
+									"type":        "string",
+									"description": "The name of the entity where the relation ends",
+								},
+								"relationType": map[string]interface{}{
+									"type":        "string",
+									"description": "The type of the relation",
+								},
+							},
+							"required": []string{"from", "to", "relationType"},
+						},
+					},
+				},
+				"required": []string{"relations"},
+			},
+		},
+		{
+			Name:        "add_observations",
+			Description: "Add new observations to existing entities in the knowledge graph",
+			InputSchema: map[string]interface{}{
+				"type": "object",
+				"properties": map[string]interface{}{
+					"observations": map[string]interface{}{
+						"type": "array",
+						"items": map[string]interface{}{
+							"type": "object",
+							"properties": map[string]interface{}{
+								"entityName": map[string]interface{}{
+									"type":        "string",
+									"description": "The name of the entity to add the observations to",
+								},
+								"contents": map[string]interface{}{
+									"type": "array",
+									"items": map[string]interface{}{
+										"type": "string",
+									},
+									"description": "An array of observation contents to add",
+								},
+							},
+							"required": []string{"entityName", "contents"},
+						},
+					},
+				},
+				"required": []string{"observations"},
+			},
+		},
+		{
+			Name:        "delete_entities",
+			Description: "Delete multiple entities and their associated relations from the knowledge graph",
+			InputSchema: map[string]interface{}{
+				"type": "object",
+				"properties": map[string]interface{}{
+					"entityNames": map[string]interface{}{
+						"type": "array",
+						"items": map[string]interface{}{
+							"type": "string",
+						},
+						"description": "An array of entity names to delete",
+					},
+				},
+				"required": []string{"entityNames"},
+			},
+		},
+		{
+			Name:        "delete_observations",
+			Description: "Delete specific observations from entities in the knowledge graph",
+			InputSchema: map[string]interface{}{
+				"type": "object",
+				"properties": map[string]interface{}{
+					"deletions": map[string]interface{}{
+						"type": "array",
+						"items": map[string]interface{}{
+							"type": "object",
+							"properties": map[string]interface{}{
+								"entityName": map[string]interface{}{
+									"type":        "string",
+									"description": "The name of the entity containing the observations",
+								},
+								"observations": map[string]interface{}{
+									"type": "array",
+									"items": map[string]interface{}{
+										"type": "string",
+									},
+									"description": "An array of observations to delete",
+								},
+							},
+							"required": []string{"entityName", "observations"},
+						},
+					},
+				},
+				"required": []string{"deletions"},
+			},
+		},
+		{
+			Name:        "delete_relations",
+			Description: "Delete multiple relations from the knowledge graph",
+			InputSchema: map[string]interface{}{
+				"type": "object",
+				"properties": map[string]interface{}{
+					"relations": map[string]interface{}{
+						"type": "array",
+						"items": map[string]interface{}{
+							"type": "object",
+							"properties": map[string]interface{}{
+								"from": map[string]interface{}{
+									"type":        "string",
+									"description": "The name of the entity where the relation starts",
+								},
+								"to": map[string]interface{}{
+									"type":        "string",
+									"description": "The name of the entity where the relation ends",
+								},
+								"relationType": map[string]interface{}{
+									"type":        "string",
+									"description": "The type of the relation",
+								},
+							},
+							"required": []string{"from", "to", "relationType"},
+						},
+					},
+				},
+				"required": []string{"relations"},
+			},
+		},
+		{
+			Name:        "read_graph",
+			Description: "Read the entire knowledge graph",
+			InputSchema: map[string]interface{}{
+				"type":       "object",
+				"properties": map[string]interface{}{},
+			},
+		},
+		{
+			Name:        "search_nodes",
+			Description: "Search for nodes in the knowledge graph based on a query",
+			InputSchema: map[string]interface{}{
+				"type": "object",
+				"properties": map[string]interface{}{
+					"query": map[string]interface{}{
+						"type":        "string",
+						"description": "The search query to match against entity names, types, and observation content",
+					},
+				},
+				"required": []string{"query"},
+			},
+		},
+		{
+			Name:        "open_nodes",
+			Description: "Open specific nodes in the knowledge graph by their names",
+			InputSchema: map[string]interface{}{
+				"type": "object",
+				"properties": map[string]interface{}{
+					"names": map[string]interface{}{
+						"type": "array",
+						"items": map[string]interface{}{
+							"type": "string",
+						},
+						"description": "An array of entity names to retrieve",
+					},
+				},
+				"required": []string{"names"},
+			},
+		},
+	}
+}
+
+// Tool handlers
+
+func (ms *MemoryServer) HandleCreateEntities(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+	ms.mu.Lock()
+	defer ms.mu.Unlock()
+
+	entitiesArg, ok := req.Arguments["entities"]
+	if !ok {
+		return mcp.NewToolError("entities parameter is required"), nil
+	}
+
+	entitiesSlice, ok := entitiesArg.([]interface{})
+	if !ok {
+		return mcp.NewToolError("entities must be an array"), nil
+	}
+
+	var createdEntities []string
+
+	for _, entityArg := range entitiesSlice {
+		entityMap, ok := entityArg.(map[string]interface{})
+		if !ok {
+			return mcp.NewToolError("each entity must be an object"), nil
+		}
+
+		name, ok := entityMap["name"].(string)
+		if !ok {
+			return mcp.NewToolError("entity name must be a string"), nil
+		}
+
+		entityType, ok := entityMap["entityType"].(string)
+		if !ok {
+			return mcp.NewToolError("entity entityType must be a string"), nil
+		}
+
+		observationsArg, ok := entityMap["observations"]
+		if !ok {
+			return mcp.NewToolError("entity observations is required"), nil
+		}
+
+		observationsSlice, ok := observationsArg.([]interface{})
+		if !ok {
+			return mcp.NewToolError("entity observations must be an array"), nil
+		}
+
+		var observations []string
+		for _, obs := range observationsSlice {
+			obsStr, ok := obs.(string)
+			if !ok {
+				return mcp.NewToolError("each observation must be a string"), nil
+			}
+			observations = append(observations, obsStr)
+		}
+
+		// Create entity
+		entity := &Entity{
+			Name:         name,
+			EntityType:   entityType,
+			Observations: observations,
+		}
+
+		ms.graph.Entities[name] = entity
+		createdEntities = append(createdEntities, name)
+	}
+
+	// Save to file
+	if err := ms.saveGraph(); err != nil {
+		return mcp.NewToolError(fmt.Sprintf("Failed to save graph: %v", err)), nil
+	}
+
+	result := fmt.Sprintf("Successfully created %d entities: %s", len(createdEntities), strings.Join(createdEntities, ", "))
+	return mcp.NewToolResult(mcp.NewTextContent(result)), nil
+}
+
+func (ms *MemoryServer) HandleCreateRelations(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+	ms.mu.Lock()
+	defer ms.mu.Unlock()
+
+	relationsArg, ok := req.Arguments["relations"]
+	if !ok {
+		return mcp.NewToolError("relations parameter is required"), nil
+	}
+
+	relationsSlice, ok := relationsArg.([]interface{})
+	if !ok {
+		return mcp.NewToolError("relations must be an array"), nil
+	}
+
+	var createdRelations []string
+
+	for _, relationArg := range relationsSlice {
+		relationMap, ok := relationArg.(map[string]interface{})
+		if !ok {
+			return mcp.NewToolError("each relation must be an object"), nil
+		}
+
+		from, ok := relationMap["from"].(string)
+		if !ok {
+			return mcp.NewToolError("relation from must be a string"), nil
+		}
+
+		to, ok := relationMap["to"].(string)
+		if !ok {
+			return mcp.NewToolError("relation to must be a string"), nil
+		}
+
+		relationType, ok := relationMap["relationType"].(string)
+		if !ok {
+			return mcp.NewToolError("relation relationType must be a string"), nil
+		}
+
+		// Check that entities exist
+		if _, exists := ms.graph.Entities[from]; !exists {
+			return mcp.NewToolError(fmt.Sprintf("entity '%s' does not exist", from)), nil
+		}
+
+		if _, exists := ms.graph.Entities[to]; !exists {
+			return mcp.NewToolError(fmt.Sprintf("entity '%s' does not exist", to)), nil
+		}
+
+		// Create relation key
+		relationKey := fmt.Sprintf("%s-%s-%s", from, relationType, to)
+
+		// Create relation
+		relation := Relation{
+			From:         from,
+			To:           to,
+			RelationType: relationType,
+		}
+
+		ms.graph.Relations[relationKey] = relation
+		createdRelations = append(createdRelations, fmt.Sprintf("%s %s %s", from, relationType, to))
+	}
+
+	// Save to file
+	if err := ms.saveGraph(); err != nil {
+		return mcp.NewToolError(fmt.Sprintf("Failed to save graph: %v", err)), nil
+	}
+
+	result := fmt.Sprintf("Successfully created %d relations: %s", len(createdRelations), strings.Join(createdRelations, ", "))
+	return mcp.NewToolResult(mcp.NewTextContent(result)), nil
+}
+
+func (ms *MemoryServer) HandleAddObservations(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+	ms.mu.Lock()
+	defer ms.mu.Unlock()
+
+	observationsArg, ok := req.Arguments["observations"]
+	if !ok {
+		return mcp.NewToolError("observations parameter is required"), nil
+	}
+
+	observationsSlice, ok := observationsArg.([]interface{})
+	if !ok {
+		return mcp.NewToolError("observations must be an array"), nil
+	}
+
+	var addedCount int
+	var addedObservations []string
+
+	for _, observationArg := range observationsSlice {
+		observationMap, ok := observationArg.(map[string]interface{})
+		if !ok {
+			return mcp.NewToolError("each observation must be an object"), nil
+		}
+
+		entityName, ok := observationMap["entityName"].(string)
+		if !ok {
+			return mcp.NewToolError("observation entityName must be a string"), nil
+		}
+
+		contentsArg, ok := observationMap["contents"]
+		if !ok {
+			return mcp.NewToolError("observation contents is required"), nil
+		}
+
+		contentsSlice, ok := contentsArg.([]interface{})
+		if !ok {
+			return mcp.NewToolError("observation contents must be an array"), nil
+		}
+
+		// Check that entity exists
+		entity, exists := ms.graph.Entities[entityName]
+		if !exists {
+			return mcp.NewToolError(fmt.Sprintf("entity '%s' does not exist", entityName)), nil
+		}
+
+		// Add observations
+		for _, content := range contentsSlice {
+			contentStr, ok := content.(string)
+			if !ok {
+				return mcp.NewToolError("each observation content must be a string"), nil
+			}
+			entity.Observations = append(entity.Observations, contentStr)
+			addedObservations = append(addedObservations, contentStr)
+			addedCount++
+		}
+	}
+
+	// Save to file
+	if err := ms.saveGraph(); err != nil {
+		return mcp.NewToolError(fmt.Sprintf("Failed to save graph: %v", err)), nil
+	}
+
+	result := fmt.Sprintf("Successfully added %d observations: %s", addedCount, strings.Join(addedObservations, ", "))
+	return mcp.NewToolResult(mcp.NewTextContent(result)), nil
+}
+
+func (ms *MemoryServer) HandleDeleteEntities(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+	ms.mu.Lock()
+	defer ms.mu.Unlock()
+
+	entityNamesArg, ok := req.Arguments["entityNames"]
+	if !ok {
+		return mcp.NewToolError("entityNames parameter is required"), nil
+	}
+
+	entityNamesSlice, ok := entityNamesArg.([]interface{})
+	if !ok {
+		return mcp.NewToolError("entityNames must be an array"), nil
+	}
+
+	var deletedEntities []string
+
+	for _, entityNameArg := range entityNamesSlice {
+		entityName, ok := entityNameArg.(string)
+		if !ok {
+			return mcp.NewToolError("each entity name must be a string"), nil
+		}
+
+		// Delete entity
+		if _, exists := ms.graph.Entities[entityName]; exists {
+			delete(ms.graph.Entities, entityName)
+			deletedEntities = append(deletedEntities, entityName)
+
+			// Delete related relations
+			for key, relation := range ms.graph.Relations {
+				if relation.From == entityName || relation.To == entityName {
+					delete(ms.graph.Relations, key)
+				}
+			}
+		}
+	}
+
+	// Save to file
+	if err := ms.saveGraph(); err != nil {
+		return mcp.NewToolError(fmt.Sprintf("Failed to save graph: %v", err)), nil
+	}
+
+	result := fmt.Sprintf("Successfully deleted %d entities: %s", len(deletedEntities), strings.Join(deletedEntities, ", "))
+	return mcp.NewToolResult(mcp.NewTextContent(result)), nil
+}
+
+func (ms *MemoryServer) HandleDeleteObservations(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+	ms.mu.Lock()
+	defer ms.mu.Unlock()
+
+	deletionsArg, ok := req.Arguments["deletions"]
+	if !ok {
+		return mcp.NewToolError("deletions parameter is required"), nil
+	}
+
+	deletionsSlice, ok := deletionsArg.([]interface{})
+	if !ok {
+		return mcp.NewToolError("deletions must be an array"), nil
+	}
+
+	var deletedCount int
+
+	for _, deletionArg := range deletionsSlice {
+		deletionMap, ok := deletionArg.(map[string]interface{})
+		if !ok {
+			return mcp.NewToolError("each deletion must be an object"), nil
+		}
+
+		entityName, ok := deletionMap["entityName"].(string)
+		if !ok {
+			return mcp.NewToolError("deletion entityName must be a string"), nil
+		}
+
+		observationsArg, ok := deletionMap["observations"]
+		if !ok {
+			return mcp.NewToolError("deletion observations is required"), nil
+		}
+
+		observationsSlice, ok := observationsArg.([]interface{})
+		if !ok {
+			return mcp.NewToolError("deletion observations must be an array"), nil
+		}
+
+		// Check that entity exists
+		entity, exists := ms.graph.Entities[entityName]
+		if !exists {
+			return mcp.NewToolError(fmt.Sprintf("entity '%s' does not exist", entityName)), nil
+		}
+
+		// Delete observations
+		for _, obsArg := range observationsSlice {
+			obsStr, ok := obsArg.(string)
+			if !ok {
+				return mcp.NewToolError("each observation must be a string"), nil
+			}
+
+			// Remove observation from entity
+			var newObservations []string
+			for _, existingObs := range entity.Observations {
+				if existingObs != obsStr {
+					newObservations = append(newObservations, existingObs)
+				} else {
+					deletedCount++
+				}
+			}
+			entity.Observations = newObservations
+		}
+	}
+
+	// Save to file
+	if err := ms.saveGraph(); err != nil {
+		return mcp.NewToolError(fmt.Sprintf("Failed to save graph: %v", err)), nil
+	}
+
+	result := fmt.Sprintf("Successfully deleted %d observations", deletedCount)
+	return mcp.NewToolResult(mcp.NewTextContent(result)), nil
+}
+
+func (ms *MemoryServer) HandleDeleteRelations(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+	ms.mu.Lock()
+	defer ms.mu.Unlock()
+
+	relationsArg, ok := req.Arguments["relations"]
+	if !ok {
+		return mcp.NewToolError("relations parameter is required"), nil
+	}
+
+	relationsSlice, ok := relationsArg.([]interface{})
+	if !ok {
+		return mcp.NewToolError("relations must be an array"), nil
+	}
+
+	var deletedRelations []string
+
+	for _, relationArg := range relationsSlice {
+		relationMap, ok := relationArg.(map[string]interface{})
+		if !ok {
+			return mcp.NewToolError("each relation must be an object"), nil
+		}
+
+		from, ok := relationMap["from"].(string)
+		if !ok {
+			return mcp.NewToolError("relation from must be a string"), nil
+		}
+
+		to, ok := relationMap["to"].(string)
+		if !ok {
+			return mcp.NewToolError("relation to must be a string"), nil
+		}
+
+		relationType, ok := relationMap["relationType"].(string)
+		if !ok {
+			return mcp.NewToolError("relation relationType must be a string"), nil
+		}
+
+		// Create relation key
+		relationKey := fmt.Sprintf("%s-%s-%s", from, relationType, to)
+
+		// Delete relation
+		if _, exists := ms.graph.Relations[relationKey]; exists {
+			delete(ms.graph.Relations, relationKey)
+			deletedRelations = append(deletedRelations, fmt.Sprintf("%s %s %s", from, relationType, to))
+		}
+	}
+
+	// Save to file
+	if err := ms.saveGraph(); err != nil {
+		return mcp.NewToolError(fmt.Sprintf("Failed to save graph: %v", err)), nil
+	}
+
+	result := fmt.Sprintf("Successfully deleted %d relations: %s", len(deletedRelations), strings.Join(deletedRelations, ", "))
+	return mcp.NewToolResult(mcp.NewTextContent(result)), nil
+}
+
+func (ms *MemoryServer) HandleReadGraph(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+	ms.mu.RLock()
+	defer ms.mu.RUnlock()
+
+	// Return the entire graph as JSON
+	graphJSON, err := json.MarshalIndent(ms.graph, "", "  ")
+	if err != nil {
+		return mcp.NewToolError(fmt.Sprintf("Failed to marshal graph: %v", err)), nil
+	}
+
+	return mcp.NewToolResult(mcp.NewTextContent(string(graphJSON))), nil
+}
+
+func (ms *MemoryServer) HandleSearchNodes(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+	ms.mu.RLock()
+	defer ms.mu.RUnlock()
+
+	query, ok := req.Arguments["query"].(string)
+	if !ok {
+		return mcp.NewToolError("query parameter is required and must be a string"), nil
+	}
+
+	query = strings.ToLower(query)
+	var matchedEntities []*Entity
+
+	// Search entities
+	for _, entity := range ms.graph.Entities {
+		// Check name
+		if strings.Contains(strings.ToLower(entity.Name), query) {
+			matchedEntities = append(matchedEntities, entity)
+			continue
+		}
+
+		// Check type
+		if strings.Contains(strings.ToLower(entity.EntityType), query) {
+			matchedEntities = append(matchedEntities, entity)
+			continue
+		}
+
+		// Check observations
+		for _, obs := range entity.Observations {
+			if strings.Contains(strings.ToLower(obs), query) {
+				matchedEntities = append(matchedEntities, entity)
+				break
+			}
+		}
+	}
+
+	// Return matched entities as JSON
+	searchResult := map[string]interface{}{
+		"query":    query,
+		"entities": matchedEntities,
+	}
+
+	resultJSON, err := json.MarshalIndent(searchResult, "", "  ")
+	if err != nil {
+		return mcp.NewToolError(fmt.Sprintf("Failed to marshal search result: %v", err)), nil
+	}
+
+	return mcp.NewToolResult(mcp.NewTextContent(string(resultJSON))), nil
+}
+
+func (ms *MemoryServer) HandleOpenNodes(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+	ms.mu.RLock()
+	defer ms.mu.RUnlock()
+
+	namesArg, ok := req.Arguments["names"]
+	if !ok {
+		return mcp.NewToolError("names parameter is required"), nil
+	}
+
+	namesSlice, ok := namesArg.([]interface{})
+	if !ok {
+		return mcp.NewToolError("names must be an array"), nil
+	}
+
+	var foundEntities []*Entity
+
+	for _, nameArg := range namesSlice {
+		name, ok := nameArg.(string)
+		if !ok {
+			return mcp.NewToolError("each name must be a string"), nil
+		}
+
+		if entity, exists := ms.graph.Entities[name]; exists {
+			foundEntities = append(foundEntities, entity)
+		}
+	}
+
+	// Return found entities as JSON
+	openResult := map[string]interface{}{
+		"entities": foundEntities,
+	}
+
+	resultJSON, err := json.MarshalIndent(openResult, "", "  ")
+	if err != nil {
+		return mcp.NewToolError(fmt.Sprintf("Failed to marshal open result: %v", err)), nil
+	}
+
+	return mcp.NewToolResult(mcp.NewTextContent(string(resultJSON))), nil
+}
+
+// Helper methods
+
+func (ms *MemoryServer) loadGraph() error {
+	if _, err := os.Stat(ms.memoryFile); os.IsNotExist(err) {
+		// File doesn't exist, start with empty graph
+		return nil
+	}
+
+	data, err := os.ReadFile(ms.memoryFile)
+	if err != nil {
+		return err
+	}
+
+	if len(data) == 0 {
+		// Empty file, start with empty graph
+		return nil
+	}
+
+	return json.Unmarshal(data, ms.graph)
+}
+
+func (ms *MemoryServer) saveGraph() error {
+	data, err := json.MarshalIndent(ms.graph, "", "  ")
+	if err != nil {
+		return err
+	}
+
+	return os.WriteFile(ms.memoryFile, data, 0644)
+}
\ No newline at end of file

@@ -0,0 +1,555 @@
+package main
+
+import (
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xlgmokha/mcp/pkg/mcp"
+)
+
+func TestMemoryServer_CreateEntities(t *testing.T) {
+	// Use temporary file for testing
+	tempDir := t.TempDir()
+	memoryFile := filepath.Join(tempDir, "test_memory.json")
+
+	server := NewMemoryServer(memoryFile)
+
+	req := mcp.CallToolRequest{
+		Name: "create_entities",
+		Arguments: map[string]interface{}{
+			"entities": []interface{}{
+				map[string]interface{}{
+					"name":         "John_Smith",
+					"entityType":   "person",
+					"observations": []interface{}{"Speaks fluent Spanish", "Works at Anthropic"},
+				},
+				map[string]interface{}{
+					"name":         "Anthropic",
+					"entityType":   "organization", 
+					"observations": []interface{}{"AI safety company"},
+				},
+			},
+		},
+	}
+
+	result, err := server.HandleCreateEntities(req)
+	if err != nil {
+		t.Fatalf("Expected no error, got %v", err)
+	}
+
+	if result.IsError {
+		textContent, _ := result.Content[0].(mcp.TextContent)
+		t.Fatalf("Expected successful entity creation, got error: %s", textContent.Text)
+	}
+
+	textContent, ok := result.Content[0].(mcp.TextContent)
+	if !ok {
+		t.Fatal("Expected TextContent")
+	}
+
+	// Should contain created entities
+	if !contains(textContent.Text, "John_Smith") {
+		t.Fatalf("Expected 'John_Smith' in result, got: %s", textContent.Text)
+	}
+
+	if !contains(textContent.Text, "Anthropic") {
+		t.Fatalf("Expected 'Anthropic' in result, got: %s", textContent.Text)
+	}
+}
+
+func TestMemoryServer_CreateRelations(t *testing.T) {
+	tempDir := t.TempDir()
+	memoryFile := filepath.Join(tempDir, "test_memory.json")
+
+	server := NewMemoryServer(memoryFile)
+
+	// First create entities
+	createReq := mcp.CallToolRequest{
+		Name: "create_entities",
+		Arguments: map[string]interface{}{
+			"entities": []interface{}{
+				map[string]interface{}{
+					"name":         "John_Smith",
+					"entityType":   "person",
+					"observations": []interface{}{"Employee"},
+				},
+				map[string]interface{}{
+					"name":         "Anthropic",
+					"entityType":   "organization",
+					"observations": []interface{}{"AI company"},
+				},
+			},
+		},
+	}
+	server.HandleCreateEntities(createReq)
+
+	// Now create relation
+	req := mcp.CallToolRequest{
+		Name: "create_relations",
+		Arguments: map[string]interface{}{
+			"relations": []interface{}{
+				map[string]interface{}{
+					"from":         "John_Smith",
+					"to":           "Anthropic",
+					"relationType": "works_at",
+				},
+			},
+		},
+	}
+
+	result, err := server.HandleCreateRelations(req)
+	if err != nil {
+		t.Fatalf("Expected no error, got %v", err)
+	}
+
+	if result.IsError {
+		textContent, _ := result.Content[0].(mcp.TextContent)
+		t.Fatalf("Expected successful relation creation, got error: %s", textContent.Text)
+	}
+
+	textContent, ok := result.Content[0].(mcp.TextContent)
+	if !ok {
+		t.Fatal("Expected TextContent")
+	}
+
+	// Should contain created relation
+	if !contains(textContent.Text, "works_at") {
+		t.Fatalf("Expected 'works_at' relation in result, got: %s", textContent.Text)
+	}
+}
+
+func TestMemoryServer_AddObservations(t *testing.T) {
+	tempDir := t.TempDir()
+	memoryFile := filepath.Join(tempDir, "test_memory.json")
+
+	server := NewMemoryServer(memoryFile)
+
+	// First create entity
+	createReq := mcp.CallToolRequest{
+		Name: "create_entities",
+		Arguments: map[string]interface{}{
+			"entities": []interface{}{
+				map[string]interface{}{
+					"name":         "John_Smith",
+					"entityType":   "person",
+					"observations": []interface{}{"Initial observation"},
+				},
+			},
+		},
+	}
+	server.HandleCreateEntities(createReq)
+
+	// Add observations
+	req := mcp.CallToolRequest{
+		Name: "add_observations",
+		Arguments: map[string]interface{}{
+			"observations": []interface{}{
+				map[string]interface{}{
+					"entityName": "John_Smith",
+					"contents":   []interface{}{"Likes coffee", "Speaks French"},
+				},
+			},
+		},
+	}
+
+	result, err := server.HandleAddObservations(req)
+	if err != nil {
+		t.Fatalf("Expected no error, got %v", err)
+	}
+
+	if result.IsError {
+		textContent, _ := result.Content[0].(mcp.TextContent)
+		t.Fatalf("Expected successful observation addition, got error: %s", textContent.Text)
+	}
+
+	textContent, ok := result.Content[0].(mcp.TextContent)
+	if !ok {
+		t.Fatal("Expected TextContent")
+	}
+
+	// Should contain added observations
+	if !contains(textContent.Text, "Likes coffee") {
+		t.Fatalf("Expected 'Likes coffee' in result, got: %s", textContent.Text)
+	}
+}
+
+func TestMemoryServer_ReadGraph(t *testing.T) {
+	tempDir := t.TempDir()
+	memoryFile := filepath.Join(tempDir, "test_memory.json")
+
+	server := NewMemoryServer(memoryFile)
+
+	// Create some test data
+	createReq := mcp.CallToolRequest{
+		Name: "create_entities",
+		Arguments: map[string]interface{}{
+			"entities": []interface{}{
+				map[string]interface{}{
+					"name":         "Alice",
+					"entityType":   "person",
+					"observations": []interface{}{"Software engineer"},
+				},
+			},
+		},
+	}
+	server.HandleCreateEntities(createReq)
+
+	// Read the graph
+	req := mcp.CallToolRequest{
+		Name:      "read_graph",
+		Arguments: map[string]interface{}{},
+	}
+
+	result, err := server.HandleReadGraph(req)
+	if err != nil {
+		t.Fatalf("Expected no error, got %v", err)
+	}
+
+	if result.IsError {
+		textContent, _ := result.Content[0].(mcp.TextContent)
+		t.Fatalf("Expected successful graph read, got error: %s", textContent.Text)
+	}
+
+	textContent, ok := result.Content[0].(mcp.TextContent)
+	if !ok {
+		t.Fatal("Expected TextContent")
+	}
+
+	// Should contain entities and relations structure
+	if !contains(textContent.Text, "entities") {
+		t.Fatalf("Expected 'entities' in graph, got: %s", textContent.Text)
+	}
+
+	if !contains(textContent.Text, "relations") {
+		t.Fatalf("Expected 'relations' in graph, got: %s", textContent.Text)
+	}
+
+	if !contains(textContent.Text, "Alice") {
+		t.Fatalf("Expected 'Alice' in graph, got: %s", textContent.Text)
+	}
+}
+
+func TestMemoryServer_SearchNodes(t *testing.T) {
+	tempDir := t.TempDir()
+	memoryFile := filepath.Join(tempDir, "test_memory.json")
+
+	server := NewMemoryServer(memoryFile)
+
+	// Create test entities
+	createReq := mcp.CallToolRequest{
+		Name: "create_entities",
+		Arguments: map[string]interface{}{
+			"entities": []interface{}{
+				map[string]interface{}{
+					"name":         "Alice_Developer",
+					"entityType":   "person",
+					"observations": []interface{}{"Python programmer", "Loves machine learning"},
+				},
+				map[string]interface{}{
+					"name":         "Bob_Manager",
+					"entityType":   "person",
+					"observations": []interface{}{"Project manager", "Excellent communication"},
+				},
+			},
+		},
+	}
+	server.HandleCreateEntities(createReq)
+
+	// Search for Python-related content
+	req := mcp.CallToolRequest{
+		Name: "search_nodes",
+		Arguments: map[string]interface{}{
+			"query": "Python",
+		},
+	}
+
+	result, err := server.HandleSearchNodes(req)
+	if err != nil {
+		t.Fatalf("Expected no error, got %v", err)
+	}
+
+	if result.IsError {
+		textContent, _ := result.Content[0].(mcp.TextContent)
+		t.Fatalf("Expected successful search, got error: %s", textContent.Text)
+	}
+
+	textContent, ok := result.Content[0].(mcp.TextContent)
+	if !ok {
+		t.Fatal("Expected TextContent")
+	}
+
+	// Should find Alice who has Python in observations
+	if !contains(textContent.Text, "Alice_Developer") {
+		t.Fatalf("Expected 'Alice_Developer' in search results, got: %s", textContent.Text)
+	}
+
+	// Should not find Bob who doesn't have Python mentioned
+	if contains(textContent.Text, "Bob_Manager") {
+		t.Fatalf("Should not find 'Bob_Manager' in Python search, got: %s", textContent.Text)
+	}
+}
+
+func TestMemoryServer_OpenNodes(t *testing.T) {
+	tempDir := t.TempDir()
+	memoryFile := filepath.Join(tempDir, "test_memory.json")
+
+	server := NewMemoryServer(memoryFile)
+
+	// Create test entities
+	createReq := mcp.CallToolRequest{
+		Name: "create_entities",
+		Arguments: map[string]interface{}{
+			"entities": []interface{}{
+				map[string]interface{}{
+					"name":         "Person1",
+					"entityType":   "person",
+					"observations": []interface{}{"First person"},
+				},
+				map[string]interface{}{
+					"name":         "Person2",
+					"entityType":   "person",
+					"observations": []interface{}{"Second person"},
+				},
+			},
+		},
+	}
+	server.HandleCreateEntities(createReq)
+
+	// Open specific nodes
+	req := mcp.CallToolRequest{
+		Name: "open_nodes",
+		Arguments: map[string]interface{}{
+			"names": []interface{}{"Person1"},
+		},
+	}
+
+	result, err := server.HandleOpenNodes(req)
+	if err != nil {
+		t.Fatalf("Expected no error, got %v", err)
+	}
+
+	if result.IsError {
+		textContent, _ := result.Content[0].(mcp.TextContent)
+		t.Fatalf("Expected successful node open, got error: %s", textContent.Text)
+	}
+
+	textContent, ok := result.Content[0].(mcp.TextContent)
+	if !ok {
+		t.Fatal("Expected TextContent")
+	}
+
+	// Should find Person1
+	if !contains(textContent.Text, "Person1") {
+		t.Fatalf("Expected 'Person1' in open nodes result, got: %s", textContent.Text)
+	}
+
+	// Should not find Person2 (not requested)
+	if contains(textContent.Text, "Person2") {
+		t.Fatalf("Should not find 'Person2' in specific node open, got: %s", textContent.Text)
+	}
+}
+
+func TestMemoryServer_DeleteEntities(t *testing.T) {
+	tempDir := t.TempDir()
+	memoryFile := filepath.Join(tempDir, "test_memory.json")
+
+	server := NewMemoryServer(memoryFile)
+
+	// Create test entity
+	createReq := mcp.CallToolRequest{
+		Name: "create_entities",
+		Arguments: map[string]interface{}{
+			"entities": []interface{}{
+				map[string]interface{}{
+					"name":         "ToDelete",
+					"entityType":   "person",
+					"observations": []interface{}{"Will be deleted"},
+				},
+			},
+		},
+	}
+	server.HandleCreateEntities(createReq)
+
+	// Delete entity
+	req := mcp.CallToolRequest{
+		Name: "delete_entities",
+		Arguments: map[string]interface{}{
+			"entityNames": []interface{}{"ToDelete"},
+		},
+	}
+
+	result, err := server.HandleDeleteEntities(req)
+	if err != nil {
+		t.Fatalf("Expected no error, got %v", err)
+	}
+
+	if result.IsError {
+		textContent, _ := result.Content[0].(mcp.TextContent)
+		t.Fatalf("Expected successful entity deletion, got error: %s", textContent.Text)
+	}
+
+	// Verify entity was deleted by reading graph
+	readReq := mcp.CallToolRequest{
+		Name:      "read_graph",
+		Arguments: map[string]interface{}{},
+	}
+
+	readResult, _ := server.HandleReadGraph(readReq)
+	readContent, _ := readResult.Content[0].(mcp.TextContent)
+
+	if contains(readContent.Text, "ToDelete") {
+		t.Fatalf("Entity should have been deleted, but found in graph: %s", readContent.Text)
+	}
+}
+
+func TestMemoryServer_DeleteObservations(t *testing.T) {
+	tempDir := t.TempDir()
+	memoryFile := filepath.Join(tempDir, "test_memory.json")
+
+	server := NewMemoryServer(memoryFile)
+
+	// Create entity with observations
+	createReq := mcp.CallToolRequest{
+		Name: "create_entities",
+		Arguments: map[string]interface{}{
+			"entities": []interface{}{
+				map[string]interface{}{
+					"name":         "TestPerson",
+					"entityType":   "person",
+					"observations": []interface{}{"Keep this", "Delete this", "Keep this too"},
+				},
+			},
+		},
+	}
+	server.HandleCreateEntities(createReq)
+
+	// Delete specific observation
+	req := mcp.CallToolRequest{
+		Name: "delete_observations",
+		Arguments: map[string]interface{}{
+			"deletions": []interface{}{
+				map[string]interface{}{
+					"entityName":   "TestPerson",
+					"observations": []interface{}{"Delete this"},
+				},
+			},
+		},
+	}
+
+	result, err := server.HandleDeleteObservations(req)
+	if err != nil {
+		t.Fatalf("Expected no error, got %v", err)
+	}
+
+	if result.IsError {
+		textContent, _ := result.Content[0].(mcp.TextContent)
+		t.Fatalf("Expected successful observation deletion, got error: %s", textContent.Text)
+	}
+
+	// Verify observation was deleted by reading graph
+	readReq := mcp.CallToolRequest{
+		Name:      "read_graph",
+		Arguments: map[string]interface{}{},
+	}
+
+	readResult, _ := server.HandleReadGraph(readReq)
+	readContent, _ := readResult.Content[0].(mcp.TextContent)
+
+	if contains(readContent.Text, "Delete this") {
+		t.Fatalf("Observation should have been deleted, but found in graph: %s", readContent.Text)
+	}
+
+	if !contains(readContent.Text, "Keep this") {
+		t.Fatalf("Other observations should remain, got: %s", readContent.Text)
+	}
+}
+
+func TestMemoryServer_ListTools(t *testing.T) {
+	tempDir := t.TempDir()
+	memoryFile := filepath.Join(tempDir, "test_memory.json")
+
+	server := NewMemoryServer(memoryFile)
+	tools := server.ListTools()
+
+	expectedTools := []string{
+		"create_entities",
+		"create_relations",
+		"add_observations",
+		"delete_entities",
+		"delete_observations",
+		"delete_relations",
+		"read_graph",
+		"search_nodes",
+		"open_nodes",
+	}
+
+	if len(tools) != len(expectedTools) {
+		t.Fatalf("Expected %d tools, got %d", len(expectedTools), len(tools))
+	}
+
+	toolNames := make(map[string]bool)
+	for _, tool := range tools {
+		toolNames[tool.Name] = true
+	}
+
+	for _, expected := range expectedTools {
+		if !toolNames[expected] {
+			t.Fatalf("Expected tool %s not found", expected)
+		}
+	}
+}
+
+func TestMemoryServer_Persistence(t *testing.T) {
+	tempDir := t.TempDir()
+	memoryFile := filepath.Join(tempDir, "test_memory.json")
+
+	// Create first server instance and add data
+	server1 := NewMemoryServer(memoryFile)
+
+	createReq := mcp.CallToolRequest{
+		Name: "create_entities",
+		Arguments: map[string]interface{}{
+			"entities": []interface{}{
+				map[string]interface{}{
+					"name":         "Persistent_Entity",
+					"entityType":   "test",
+					"observations": []interface{}{"This should persist"},
+				},
+			},
+		},
+	}
+	server1.HandleCreateEntities(createReq)
+
+	// Create second server instance (should load from file)
+	server2 := NewMemoryServer(memoryFile)
+
+	readReq := mcp.CallToolRequest{
+		Name:      "read_graph",
+		Arguments: map[string]interface{}{},
+	}
+
+	result, err := server2.HandleReadGraph(readReq)
+	if err != nil {
+		t.Fatalf("Expected no error, got %v", err)
+	}
+
+	textContent, ok := result.Content[0].(mcp.TextContent)
+	if !ok {
+		t.Fatal("Expected TextContent")
+	}
+
+	// Should find the entity created by the first server instance
+	if !contains(textContent.Text, "Persistent_Entity") {
+		t.Fatalf("Expected persistent entity to be loaded from file, got: %s", textContent.Text)
+	}
+
+	if !contains(textContent.Text, "This should persist") {
+		t.Fatalf("Expected persistent observation to be loaded from file, got: %s", textContent.Text)
+	}
+}
+
+// Helper functions
+func contains(s, substr string) bool {
+	return strings.Contains(s, substr)
+}
\ No newline at end of file

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"context"
+	"log"
+
+	"github.com/xlgmokha/mcp/pkg/mcp"
+)
+
+func main() {
+	server := NewSequentialThinkingServer()
+	
+	// Set up basic initialization
+	server.SetInitializeHandler(func(req mcp.InitializeRequest) (mcp.InitializeResult, error) {
+		// Use default initialization
+		return mcp.InitializeResult{}, nil
+	})
+	
+	ctx := context.Background()
+	if err := server.Run(ctx); err != nil {
+		log.Fatalf("Server error: %v", err)
+	}
+}
\ No newline at end of file

@@ -0,0 +1,395 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/xlgmokha/mcp/pkg/mcp"
+)
+
+// SequentialThinkingServer implements the Sequential Thinking MCP server
+type SequentialThinkingServer struct {
+	*mcp.Server
+}
+
+// ThinkingSession represents a thinking session with sequential thoughts
+type ThinkingSession struct {
+	Thoughts      []Thought `json:"thoughts"`
+	CurrentThought int      `json:"current_thought"`
+	TotalThoughts int       `json:"total_thoughts"`
+	Status        string    `json:"status"` // "active", "completed"
+}
+
+// Thought represents a single thought in the sequence
+type Thought struct {
+	Number           int    `json:"number"`
+	Content          string `json:"content"`
+	IsRevision       bool   `json:"is_revision,omitempty"`
+	RevisesThought   *int   `json:"revises_thought,omitempty"`
+	BranchFromThought *int  `json:"branch_from_thought,omitempty"`
+	BranchID         string `json:"branch_id,omitempty"`
+	NeedsMoreThoughts bool  `json:"needs_more_thoughts,omitempty"`
+}
+
+// ThinkingResponse represents the response structure
+type ThinkingResponse struct {
+	Thought           string `json:"thought"`
+	ThoughtNumber     int    `json:"thought_number"`
+	TotalThoughts     int    `json:"total_thoughts"`
+	NextThoughtNeeded bool   `json:"next_thought_needed"`
+	Status            string `json:"status"`
+	Solution          string `json:"solution,omitempty"`
+}
+
+// NewSequentialThinkingServer creates a new Sequential Thinking MCP server
+func NewSequentialThinkingServer() *SequentialThinkingServer {
+	server := mcp.NewServer("mcp-sequential-thinking", "1.0.0")
+
+	thinkingServer := &SequentialThinkingServer{
+		Server: server,
+	}
+
+	// Register all sequential thinking tools
+	thinkingServer.registerTools()
+
+	return thinkingServer
+}
+
+// registerTools registers all Sequential Thinking tools with the server
+func (sts *SequentialThinkingServer) registerTools() {
+	sts.RegisterTool("sequentialthinking", sts.HandleSequentialThinking)
+}
+
+// ListTools returns all available Sequential Thinking tools
+func (sts *SequentialThinkingServer) ListTools() []mcp.Tool {
+	return []mcp.Tool{
+		{
+			Name:        "sequentialthinking",
+			Description: "A detailed tool for dynamic and reflective problem-solving through thoughts. This tool helps analyze problems through a flexible thinking process that can adapt and evolve. Each thought can build on, question, or revise previous insights as understanding deepens.",
+			InputSchema: map[string]interface{}{
+				"type": "object",
+				"properties": map[string]interface{}{
+					"thought": map[string]interface{}{
+						"type":        "string",
+						"description": "Your current thinking step",
+					},
+					"nextThoughtNeeded": map[string]interface{}{
+						"type":        "boolean",
+						"description": "Whether another thought step is needed",
+					},
+					"thoughtNumber": map[string]interface{}{
+						"type":        "integer",
+						"minimum":     1,
+						"description": "Current thought number",
+					},
+					"totalThoughts": map[string]interface{}{
+						"type":        "integer",
+						"minimum":     1,
+						"description": "Estimated total thoughts needed",
+					},
+					"isRevision": map[string]interface{}{
+						"type":        "boolean",
+						"description": "Whether this revises previous thinking",
+						"default":     false,
+					},
+					"revisesThought": map[string]interface{}{
+						"type":        "integer",
+						"minimum":     1,
+						"description": "Which thought is being reconsidered",
+					},
+					"branchFromThought": map[string]interface{}{
+						"type":        "integer",
+						"minimum":     1,
+						"description": "Branching point thought number",
+					},
+					"branchId": map[string]interface{}{
+						"type":        "string",
+						"description": "Branch identifier",
+					},
+					"needsMoreThoughts": map[string]interface{}{
+						"type":        "boolean",
+						"description": "If more thoughts are needed",
+						"default":     false,
+					},
+				},
+				"required": []string{"thought", "nextThoughtNeeded", "thoughtNumber", "totalThoughts"},
+			},
+		},
+	}
+}
+
+// Tool handlers
+
+func (sts *SequentialThinkingServer) HandleSequentialThinking(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
+	// Parse input parameters
+	thought, ok := req.Arguments["thought"].(string)
+	if !ok {
+		return mcp.NewToolError("thought parameter is required and must be a string"), nil
+	}
+
+	nextThoughtNeeded, ok := req.Arguments["nextThoughtNeeded"].(bool)
+	if !ok {
+		return mcp.NewToolError("nextThoughtNeeded parameter is required and must be a boolean"), nil
+	}
+
+	thoughtNumber := 1
+	if tn, ok := req.Arguments["thoughtNumber"]; ok {
+		switch v := tn.(type) {
+		case float64:
+			thoughtNumber = int(v)
+		case int:
+			thoughtNumber = v
+		default:
+			return mcp.NewToolError("thoughtNumber must be a number"), nil
+		}
+		if thoughtNumber < 1 {
+			return mcp.NewToolError("thoughtNumber must be >= 1"), nil
+		}
+	}
+
+	totalThoughts := 1
+	if tt, ok := req.Arguments["totalThoughts"]; ok {
+		switch v := tt.(type) {
+		case float64:
+			totalThoughts = int(v)
+		case int:
+			totalThoughts = v
+		default:
+			return mcp.NewToolError("totalThoughts must be a number"), nil
+		}
+		if totalThoughts < 1 {
+			return mcp.NewToolError("totalThoughts must be >= 1"), nil
+		}
+	}
+
+	// Parse optional parameters
+	isRevision := false
+	if ir, ok := req.Arguments["isRevision"].(bool); ok {
+		isRevision = ir
+	}
+
+	var revisesThought *int
+	if rt, ok := req.Arguments["revisesThought"]; ok && isRevision {
+		switch v := rt.(type) {
+		case float64:
+			val := int(v)
+			revisesThought = &val
+		case int:
+			revisesThought = &v
+		default:
+			return mcp.NewToolError("revisesThought must be a number"), nil
+		}
+	}
+
+	var branchFromThought *int
+	if bft, ok := req.Arguments["branchFromThought"]; ok {
+		switch v := bft.(type) {
+		case float64:
+			val := int(v)
+			branchFromThought = &val
+		case int:
+			branchFromThought = &v
+		default:
+			return mcp.NewToolError("branchFromThought must be a number"), nil
+		}
+	}
+
+	branchID := ""
+	if bid, ok := req.Arguments["branchId"].(string); ok {
+		branchID = bid
+	}
+
+	needsMoreThoughts := false
+	if nmt, ok := req.Arguments["needsMoreThoughts"].(bool); ok {
+		needsMoreThoughts = nmt
+	}
+
+	// Create thought object
+	currentThought := Thought{
+		Number:            thoughtNumber,
+		Content:           thought,
+		IsRevision:        isRevision,
+		RevisesThought:    revisesThought,
+		BranchFromThought: branchFromThought,
+		BranchID:          branchID,
+		NeedsMoreThoughts: needsMoreThoughts,
+	}
+
+	// Determine status
+	status := "thinking"
+	if !nextThoughtNeeded {
+		status = "completed"
+	} else if thoughtNumber >= totalThoughts && !needsMoreThoughts {
+		status = "completed"
+	}
+
+	// Create response
+	response := ThinkingResponse{
+		Thought:           thought,
+		ThoughtNumber:     thoughtNumber,
+		TotalThoughts:     totalThoughts,
+		NextThoughtNeeded: nextThoughtNeeded,
+		Status:            status,
+	}
+
+	// If this is the final thought, try to extract a solution
+	if status == "completed" {
+		response.Solution = sts.extractSolution(thought)
+	}
+
+	// Add context information
+	var contextInfo []string
+	
+	if isRevision && revisesThought != nil {
+		contextInfo = append(contextInfo, fmt.Sprintf("Revising thought %d", *revisesThought))
+	}
+	
+	if branchFromThought != nil {
+		contextInfo = append(contextInfo, fmt.Sprintf("Branching from thought %d", *branchFromThought))
+		if branchID != "" {
+			contextInfo = append(contextInfo, fmt.Sprintf("Branch: %s", branchID))
+		}
+	}
+	
+	if needsMoreThoughts {
+		contextInfo = append(contextInfo, "Requesting additional thoughts beyond initial estimate")
+	}
+
+	// Format the result
+	resultText := sts.formatThinkingResult(response, currentThought, contextInfo)
+
+	return mcp.NewToolResult(mcp.NewTextContent(resultText)), nil
+}
+
+// Helper methods
+
+func (sts *SequentialThinkingServer) extractSolution(finalThought string) string {
+	// Simple heuristic to extract a solution from the final thought
+	content := strings.ToLower(finalThought)
+	
+	// Look for solution indicators (with and without colons)
+	solutionKeywords := []string{
+		"solution:",
+		"solution is",
+		"answer:",
+		"answer is", 
+		"conclusion:",
+		"final answer:",
+		"result:",
+		"therefore:",
+		"therefore,",
+		"therefore the",
+		"in conclusion:",
+	}
+	
+	for _, keyword := range solutionKeywords {
+		if idx := strings.Index(content, keyword); idx != -1 {
+			// Extract text after the keyword
+			remaining := strings.TrimSpace(finalThought[idx+len(keyword):])
+			if len(remaining) > 0 {
+				// Take up to the first sentence or 200 characters
+				if sentences := strings.Split(remaining, "."); len(sentences) > 0 {
+					solution := strings.TrimSpace(sentences[0])
+					if len(solution) > 200 {
+						solution = solution[:200] + "..."
+					}
+					if solution != "" {
+						return solution
+					}
+				}
+			}
+		}
+	}
+	
+	// If no explicit solution found, return the last sentence or a portion
+	sentences := strings.Split(strings.TrimSpace(finalThought), ".")
+	if len(sentences) > 0 {
+		lastSentence := strings.TrimSpace(sentences[len(sentences)-1])
+		if len(lastSentence) > 200 {
+			lastSentence = lastSentence[:200] + "..."
+		}
+		if lastSentence != "" {
+			return lastSentence
+		}
+	}
+	
+	return "Solution extracted from final thought"
+}
+
+func (sts *SequentialThinkingServer) formatThinkingResult(response ThinkingResponse, thought Thought, contextInfo []string) string {
+	var result strings.Builder
+	
+	// Header
+	result.WriteString(fmt.Sprintf("🧠 Sequential Thinking - Thought %d/%d\n", 
+		response.ThoughtNumber, response.TotalThoughts))
+	result.WriteString("═══════════════════════════════════════\n\n")
+	
+	// Context information if any
+	if len(contextInfo) > 0 {
+		result.WriteString("📝 Context: " + strings.Join(contextInfo, ", ") + "\n\n")
+	}
+	
+	// Main thought content
+	result.WriteString("💭 Current Thought:\n")
+	result.WriteString(response.Thought + "\n\n")
+	
+	// Progress indicator
+	progressBar := sts.createProgressBar(response.ThoughtNumber, response.TotalThoughts)
+	result.WriteString("📊 Progress: " + progressBar + "\n\n")
+	
+	// Status
+	statusEmoji := "🔄"
+	if response.Status == "completed" {
+		statusEmoji = "✅"
+	}
+	result.WriteString(fmt.Sprintf("%s Status: %s\n", statusEmoji, response.Status))
+	
+	if response.NextThoughtNeeded {
+		result.WriteString("⏭️  Next thought needed\n")
+	} else {
+		result.WriteString("🏁 Thinking sequence complete\n")
+	}
+	
+	// Solution if available
+	if response.Solution != "" {
+		result.WriteString("\n🎯 Extracted Solution:\n")
+		result.WriteString(response.Solution + "\n")
+	}
+	
+	// JSON data for programmatic access
+	result.WriteString("\n📋 Structured Data:\n")
+	jsonData, _ := json.MarshalIndent(response, "", "  ")
+	result.WriteString("```json\n")
+	result.WriteString(string(jsonData))
+	result.WriteString("\n```")
+	
+	return result.String()
+}
+
+func (sts *SequentialThinkingServer) createProgressBar(current, total int) string {
+	if total <= 0 {
+		return "[████████████████████] 100%"
+	}
+	
+	percentage := float64(current) / float64(total) * 100
+	if percentage > 100 {
+		percentage = 100
+	}
+	
+	barLength := 20
+	filledLength := int(percentage / 100 * float64(barLength))
+	
+	bar := "["
+	for i := 0; i < barLength; i++ {
+		if i < filledLength {
+			bar += "█"
+		} else {
+			bar += "░"
+		}
+	}
+	bar += "] " + strconv.Itoa(int(percentage)) + "%"
+	
+	return bar
+}
\ No newline at end of file

@@ -0,0 +1,374 @@
+package main
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/xlgmokha/mcp/pkg/mcp"
+)
+
+func TestSequentialThinkingServer_BasicThinking(t *testing.T) {
+	server := NewSequentialThinkingServer()
+
+	req := mcp.CallToolRequest{
+		Name: "sequentialthinking",
+		Arguments: map[string]interface{}{
+			"thought":            "Let me analyze this problem step by step.",
+			"nextThoughtNeeded":  true,
+			"thoughtNumber":      1,
+			"totalThoughts":      3,
+		},
+	}
+
+	result, err := server.HandleSequentialThinking(req)
+	if err != nil {
+		t.Fatalf("Expected no error, got %v", err)
+	}
+
+	if result.IsError {
+		textContent, _ := result.Content[0].(mcp.TextContent)
+		t.Fatalf("Expected successful thinking, got error: %s", textContent.Text)
+	}
+
+	textContent, ok := result.Content[0].(mcp.TextContent)
+	if !ok {
+		t.Fatal("Expected TextContent")
+	}
+
+	// Should contain the thought content
+	if !contains(textContent.Text, "analyze this problem") {
+		t.Fatalf("Expected thought content in result, got: %s", textContent.Text)
+	}
+
+	// Should show progress
+	if !contains(textContent.Text, "Thought 1/3") {
+		t.Fatalf("Expected progress indicator, got: %s", textContent.Text)
+	}
+
+	// Should indicate thinking status
+	if !contains(textContent.Text, "thinking") {
+		t.Fatalf("Expected thinking status, got: %s", textContent.Text)
+	}
+}
+
+func TestSequentialThinkingServer_CompletedThinking(t *testing.T) {
+	server := NewSequentialThinkingServer()
+
+	req := mcp.CallToolRequest{
+		Name: "sequentialthinking",
+		Arguments: map[string]interface{}{
+			"thought":            "Therefore, the solution is 42.",
+			"nextThoughtNeeded":  false,
+			"thoughtNumber":      3,
+			"totalThoughts":      3,
+		},
+	}
+
+	result, err := server.HandleSequentialThinking(req)
+	if err != nil {
+		t.Fatalf("Expected no error, got %v", err)
+	}
+
+	if result.IsError {
+		textContent, _ := result.Content[0].(mcp.TextContent)
+		t.Fatalf("Expected successful thinking, got error: %s", textContent.Text)
+	}
+
+	textContent, ok := result.Content[0].(mcp.TextContent)
+	if !ok {
+		t.Fatal("Expected TextContent")
+	}
+
+	// Should contain the thought content
+	if !contains(textContent.Text, "solution is 42") {
+		t.Fatalf("Expected thought content in result, got: %s", textContent.Text)
+	}
+
+	// Should show completed status
+	if !contains(textContent.Text, "completed") {
+		t.Fatalf("Expected completed status, got: %s", textContent.Text)
+	}
+
+	// Should extract solution
+	if !contains(textContent.Text, "Extracted Solution") {
+		t.Fatalf("Expected extracted solution, got: %s", textContent.Text)
+	}
+}
+
+func TestSequentialThinkingServer_RevisionThinking(t *testing.T) {
+	server := NewSequentialThinkingServer()
+
+	req := mcp.CallToolRequest{
+		Name: "sequentialthinking",
+		Arguments: map[string]interface{}{
+			"thought":            "Actually, let me reconsider my previous analysis.",
+			"nextThoughtNeeded":  true,
+			"thoughtNumber":      4,
+			"totalThoughts":      5,
+			"isRevision":         true,
+			"revisesThought":     2,
+		},
+	}
+
+	result, err := server.HandleSequentialThinking(req)
+	if err != nil {
+		t.Fatalf("Expected no error, got %v", err)
+	}
+
+	if result.IsError {
+		textContent, _ := result.Content[0].(mcp.TextContent)
+		t.Fatalf("Expected successful thinking, got error: %s", textContent.Text)
+	}
+
+	textContent, ok := result.Content[0].(mcp.TextContent)
+	if !ok {
+		t.Fatal("Expected TextContent")
+	}
+
+	// Should contain revision context
+	if !contains(textContent.Text, "Revising thought 2") {
+		t.Fatalf("Expected revision context, got: %s", textContent.Text)
+	}
+
+	// Should contain the thought content
+	if !contains(textContent.Text, "reconsider my previous") {
+		t.Fatalf("Expected thought content in result, got: %s", textContent.Text)
+	}
+}
+
+func TestSequentialThinkingServer_BranchThinking(t *testing.T) {
+	server := NewSequentialThinkingServer()
+
+	req := mcp.CallToolRequest{
+		Name: "sequentialthinking",
+		Arguments: map[string]interface{}{
+			"thought":             "Let me explore an alternative approach.",
+			"nextThoughtNeeded":   true,
+			"thoughtNumber":       6,
+			"totalThoughts":       8,
+			"branchFromThought":   3,
+			"branchId":            "alternative_path",
+		},
+	}
+
+	result, err := server.HandleSequentialThinking(req)
+	if err != nil {
+		t.Fatalf("Expected no error, got %v", err)
+	}
+
+	if result.IsError {
+		textContent, _ := result.Content[0].(mcp.TextContent)
+		t.Fatalf("Expected successful thinking, got error: %s", textContent.Text)
+	}
+
+	textContent, ok := result.Content[0].(mcp.TextContent)
+	if !ok {
+		t.Fatal("Expected TextContent")
+	}
+
+	// Should contain branch context
+	if !contains(textContent.Text, "Branching from thought 3") {
+		t.Fatalf("Expected branch context, got: %s", textContent.Text)
+	}
+
+	if !contains(textContent.Text, "alternative_path") {
+		t.Fatalf("Expected branch ID, got: %s", textContent.Text)
+	}
+}
+
+func TestSequentialThinkingServer_NeedsMoreThoughts(t *testing.T) {
+	server := NewSequentialThinkingServer()
+
+	req := mcp.CallToolRequest{
+		Name: "sequentialthinking",
+		Arguments: map[string]interface{}{
+			"thought":             "I realize I need more steps to solve this.",
+			"nextThoughtNeeded":   true,
+			"thoughtNumber":       5,
+			"totalThoughts":       5,
+			"needsMoreThoughts":   true,
+		},
+	}
+
+	result, err := server.HandleSequentialThinking(req)
+	if err != nil {
+		t.Fatalf("Expected no error, got %v", err)
+	}
+
+	if result.IsError {
+		textContent, _ := result.Content[0].(mcp.TextContent)
+		t.Fatalf("Expected successful thinking, got error: %s", textContent.Text)
+	}
+
+	textContent, ok := result.Content[0].(mcp.TextContent)
+	if !ok {
+		t.Fatal("Expected TextContent")
+	}
+
+	// Should contain more thoughts context
+	if !contains(textContent.Text, "additional thoughts") {
+		t.Fatalf("Expected additional thoughts context, got: %s", textContent.Text)
+	}
+
+	// Should still be thinking status even though at total thoughts
+	if !contains(textContent.Text, "thinking") {
+		t.Fatalf("Expected thinking status, got: %s", textContent.Text)
+	}
+}
+
+func TestSequentialThinkingServer_MissingRequiredParams(t *testing.T) {
+	server := NewSequentialThinkingServer()
+
+	req := mcp.CallToolRequest{
+		Name: "sequentialthinking",
+		Arguments: map[string]interface{}{
+			"thought": "Missing required params",
+			// Missing nextThoughtNeeded, thoughtNumber, totalThoughts
+		},
+	}
+
+	result, err := server.HandleSequentialThinking(req)
+	if err != nil {
+		t.Fatalf("Expected no error, got %v", err)
+	}
+
+	if !result.IsError {
+		t.Fatal("Expected error for missing required parameters")
+	}
+
+	textContent, ok := result.Content[0].(mcp.TextContent)
+	if !ok {
+		t.Fatal("Expected TextContent")
+	}
+
+	if !contains(textContent.Text, "required") {
+		t.Fatalf("Expected required parameter error, got: %s", textContent.Text)
+	}
+}
+
+func TestSequentialThinkingServer_InvalidParams(t *testing.T) {
+	server := NewSequentialThinkingServer()
+
+	req := mcp.CallToolRequest{
+		Name: "sequentialthinking",
+		Arguments: map[string]interface{}{
+			"thought":            "Test thought",
+			"nextThoughtNeeded":  true,
+			"thoughtNumber":      0, // Invalid: must be >= 1
+			"totalThoughts":      3,
+		},
+	}
+
+	result, err := server.HandleSequentialThinking(req)
+	if err != nil {
+		t.Fatalf("Expected no error, got %v", err)
+	}
+
+	if !result.IsError {
+		t.Fatal("Expected error for invalid thoughtNumber")
+	}
+
+	textContent, ok := result.Content[0].(mcp.TextContent)
+	if !ok {
+		t.Fatal("Expected TextContent")
+	}
+
+	if !contains(textContent.Text, "must be >= 1") {
+		t.Fatalf("Expected thoughtNumber validation error, got: %s", textContent.Text)
+	}
+}
+
+func TestSequentialThinkingServer_SolutionExtraction(t *testing.T) {
+	server := NewSequentialThinkingServer()
+
+	// Test with explicit solution keyword
+	req := mcp.CallToolRequest{
+		Name: "sequentialthinking",
+		Arguments: map[string]interface{}{
+			"thought":            "After careful analysis, the answer is: The optimal solution involves using a binary search algorithm.",
+			"nextThoughtNeeded":  false,
+			"thoughtNumber":      3,
+			"totalThoughts":      3,
+		},
+	}
+
+	result, err := server.HandleSequentialThinking(req)
+	if err != nil {
+		t.Fatalf("Expected no error, got %v", err)
+	}
+
+	textContent, ok := result.Content[0].(mcp.TextContent)
+	if !ok {
+		t.Fatal("Expected TextContent")
+	}
+
+	// Should extract the solution
+	if !contains(textContent.Text, "binary search algorithm") {
+		t.Fatalf("Expected extracted solution to contain key phrase, got: %s", textContent.Text)
+	}
+}
+
+func TestSequentialThinkingServer_ListTools(t *testing.T) {
+	server := NewSequentialThinkingServer()
+	tools := server.ListTools()
+
+	expectedTools := []string{
+		"sequentialthinking",
+	}
+
+	if len(tools) != len(expectedTools) {
+		t.Fatalf("Expected %d tools, got %d", len(expectedTools), len(tools))
+	}
+
+	toolNames := make(map[string]bool)
+	for _, tool := range tools {
+		toolNames[tool.Name] = true
+	}
+
+	for _, expected := range expectedTools {
+		if !toolNames[expected] {
+			t.Fatalf("Expected tool %s not found", expected)
+		}
+	}
+
+	// Check that sequentialthinking tool has proper schema
+	thinkingTool := tools[0]
+	if thinkingTool.Name != "sequentialthinking" {
+		t.Fatalf("Expected first tool to be 'sequentialthinking', got %s", thinkingTool.Name)
+	}
+
+	if thinkingTool.Description == "" {
+		t.Fatal("Expected non-empty description for sequentialthinking tool")
+	}
+
+	if thinkingTool.InputSchema == nil {
+		t.Fatal("Expected input schema for sequentialthinking tool")
+	}
+}
+
+func TestSequentialThinkingServer_ProgressBar(t *testing.T) {
+	server := NewSequentialThinkingServer()
+
+	// Test progress bar creation
+	progressBar := server.createProgressBar(3, 10)
+	if !contains(progressBar, "30%") {
+		t.Fatalf("Expected 30%% progress, got: %s", progressBar)
+	}
+
+	// Test 100% completion
+	progressBar = server.createProgressBar(5, 5)
+	if !contains(progressBar, "100%") {
+		t.Fatalf("Expected 100%% progress, got: %s", progressBar)
+	}
+
+	// Test over 100%
+	progressBar = server.createProgressBar(7, 5)
+	if !contains(progressBar, "100%") {
+		t.Fatalf("Expected capped at 100%% progress, got: %s", progressBar)
+	}
+}
+
+// Helper functions
+func contains(s, substr string) bool {
+	return strings.Contains(s, substr)
+}
\ No newline at end of file