diff --git a/code/backend/cmd/server/main.go b/code/backend/cmd/server/main.go
index 063fd11..becbeee 100644
--- a/code/backend/cmd/server/main.go
+++ b/code/backend/cmd/server/main.go
@@ -81,6 +81,10 @@ func main() {
 	})
 	app.POST("/user", apiCfg.HandlerUser)
 	app.POST("/log", auth.MiddlewareAuth(apiCfg.LogHandler))
+	app.GET("/parsers", apiCfg.ListParsersHandler)
+	app.GET("/parsers/:id", apiCfg.GetParserHandler)
+	app.PATCH("/parsers/:id", apiCfg.UpdateParserHandler)
+	app.POST("/parsers", apiCfg.CreateParserHandler)
 
 	// schedular init
 	sched := schedular.NewSchedular(mongod, JobChan)
diff --git a/code/backend/internal/api/parser.go b/code/backend/internal/api/parser.go
new file mode 100644
index 0000000..e1ac36f
--- /dev/null
+++ b/code/backend/internal/api/parser.go
@@ -0,0 +1,199 @@
+package api
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"net/http"
+	"strings"
+
+	"github.com/EleventhHour-Projects/GoLogGo/code/backend/internal/database"
+	"github.com/EleventhHour-Projects/GoLogGo/code/backend/internal/parser"
+	"github.com/nottechdm/notnet/pkg/notnet"
+	"go.mongodb.org/mongo-driver/v2/bson"
+	"go.mongodb.org/mongo-driver/v2/mongo"
+)
+
+// ListParsersHandler returns all parsers from MongoDB along with calculated aggregate metrics.
+func (api *Config) ListParsersHandler(req *notnet.Request, res *notnet.Response) error {
+	ctx := req.HTTPRequest.Context()
+	parsers, err := api.Reqs.FindAllParsers(ctx)
+	if err != nil {
+		return res.JSON(http.StatusInternalServerError, map[string]string{
+			"error": "failed to fetch parsers from database",
+		})
+	}
+
+	var activeCount int
+	var totalLogsProcessed int64
+	for _, p := range parsers {
+		if strings.EqualFold(p.Status, "active") {
+			activeCount++
+		}
+		totalLogsProcessed += p.LogsProcessed
+	}
+
+	return res.JSON(http.StatusOK, map[string]interface{}{
+		"parsers": parsers,
+		"metrics": map[string]interface{}{
+			"totalParsers":       len(parsers),
+			"activeParsers":      activeCount,
+			"totalLogsProcessed": totalLogsProcessed,
+		},
+	})
+}
+
+// GetParserHandler returns a single parser by its ObjectID or hash.
+func (api *Config) GetParserHandler(req *notnet.Request, res *notnet.Response) error {
+	ctx := req.HTTPRequest.Context()
+	idOrHash := req.Param("id")
+	if idOrHash == "" {
+		return res.JSON(http.StatusBadRequest, map[string]string{
+			"error": "parser id or hash is required",
+		})
+	}
+
+	var p *database.ParserDoc
+	var err error
+
+	if objID, parseErr := bson.ObjectIDFromHex(idOrHash); parseErr == nil {
+		p, err = api.Reqs.FindParserByID(ctx, objID)
+	} else {
+		p, err = api.Reqs.FindParserByHash(ctx, idOrHash)
+	}
+
+	if err != nil {
+		if errors.Is(err, mongo.ErrNoDocuments) {
+			return res.JSON(http.StatusNotFound, map[string]string{
+				"error": "parser not found",
+			})
+		}
+		return res.JSON(http.StatusInternalServerError, map[string]string{
+			"error": "failed to retrieve parser",
+		})
+	}
+
+	return res.JSON(http.StatusOK, p)
+}
+
+// UpdateParserHandler updates the name, format, or status of an existing parser.
+func (api *Config) UpdateParserHandler(req *notnet.Request, res *notnet.Response) error {
+	ctx := req.HTTPRequest.Context()
+	idStr := req.Param("id")
+	if idStr == "" {
+		return res.JSON(http.StatusBadRequest, map[string]string{
+			"error": "parser id is required",
+		})
+	}
+
+	objID, err := bson.ObjectIDFromHex(idStr)
+	if err != nil {
+		// If not ObjectID, check if it's a hash
+		doc, findErr := api.Reqs.FindParserByHash(ctx, idStr)
+		if findErr != nil {
+			return res.JSON(http.StatusBadRequest, map[string]string{
+				"error": "invalid parser id or hash",
+			})
+		}
+		objID = doc.ID
+	}
+
+	type updatePayload struct {
+		Name   string `json:"name"`
+		Format string `json:"format"`
+		Status string `json:"status"`
+	}
+
+	var payload updatePayload
+	if err := json.NewDecoder(req.HTTPRequest.Body).Decode(&payload); err != nil {
+		return res.JSON(http.StatusBadRequest, map[string]string{
+			"error": "invalid request body",
+		})
+	}
+
+	updated, err := api.Reqs.UpdateParser(ctx, objID, payload.Name, payload.Format, payload.Status)
+	if err != nil {
+		return res.JSON(http.StatusInternalServerError, map[string]string{
+			"error": "failed to update parser",
+		})
+	}
+
+	return res.JSON(http.StatusOK, map[string]interface{}{
+		"success": true,
+		"parser":  updated,
+	})
+}
+
+// CreateParserHandler allows manual creation of a log parser.
+func (api *Config) CreateParserHandler(req *notnet.Request, res *notnet.Response) error {
+	ctx := req.HTTPRequest.Context()
+
+	type createPayload struct {
+		Name            string                           `json:"name"`
+		Format          string                           `json:"format"`
+		Pattern         string                           `json:"pattern"`
+		Mapping         map[string]string                `json:"mapping"`
+		Transformations map[string]parser.Transformation `json:"transformations,omitempty"`
+		Status          string                           `json:"status"`
+		SampleLog       string                           `json:"sampleLog,omitempty"`
+	}
+
+	var payload createPayload
+	if err := json.NewDecoder(req.HTTPRequest.Body).Decode(&payload); err != nil {
+		return res.JSON(http.StatusBadRequest, map[string]string{
+			"error": "invalid request body",
+		})
+	}
+
+	if payload.Pattern == "" {
+		return res.JSON(http.StatusBadRequest, map[string]string{
+			"error": "pattern is required",
+		})
+	}
+
+	if payload.Name == "" {
+		if payload.Format != "" {
+			payload.Name = payload.Format + "Parser"
+		} else {
+			payload.Name = "CustomParser"
+		}
+	}
+	if payload.Status == "" {
+		payload.Status = "Active"
+	}
+	if payload.Format == "" {
+		payload.Format = "Custom"
+	}
+	if payload.Mapping == nil {
+		payload.Mapping = make(map[string]string)
+	}
+
+	// Generate deterministic hash from pattern
+	h := sha256.New()
+	h.Write([]byte(payload.Pattern))
+	hash := hex.EncodeToString(h.Sum(nil))[:16]
+
+	doc := database.ParserDoc{
+		Name:            payload.Name,
+		Hash:            hash,
+		Pattern:         payload.Pattern,
+		Mapping:         payload.Mapping,
+		Transformations: payload.Transformations,
+		Status:          payload.Status,
+		Format:          payload.Format,
+		SampleLog:       payload.SampleLog,
+	}
+
+	saved, err := api.Reqs.SaveParser(ctx, &doc)
+	if err != nil {
+		return res.JSON(http.StatusInternalServerError, map[string]string{
+			"error": "failed to save parser to database",
+		})
+	}
+
+	return res.JSON(http.StatusCreated, map[string]interface{}{
+		"success": true,
+		"parser":  saved,
+	})
+}
diff --git a/code/backend/internal/database/config.go b/code/backend/internal/database/config.go
index 9ee2874..94394db 100644
--- a/code/backend/internal/database/config.go
+++ b/code/backend/internal/database/config.go
@@ -20,6 +20,9 @@ const (
 
 	// CollectionLogs is the name of the logs collection in MongoDB.
 	CollectionLogs MongoDBCollection = "logs"
+
+	// CollectionParsers is the name of the parsers collection in MongoDB.
+	CollectionParsers MongoDBCollection = "parsers"
 )
 
 type MongoDB struct {
@@ -67,6 +70,7 @@ func New(ctx context.Context, config MongoDBOptions) (*MongoDB, error) {
 			CollectionUsers:    db.Collection(string(CollectionUsers)),
 			CollectionRequests: db.Collection(string(CollectionRequests)),
 			CollectionLogs:     db.Collection(string(CollectionLogs)),
+			CollectionParsers:  db.Collection(string(CollectionParsers)),
 		},
 	}, nil
 }
diff --git a/code/backend/internal/database/mongodb.go b/code/backend/internal/database/mongodb.go
index 797fbe7..586e323 100644
--- a/code/backend/internal/database/mongodb.go
+++ b/code/backend/internal/database/mongodb.go
@@ -189,3 +189,217 @@ func (m *MongoDB) InsertLog(ctx context.Context, req Req, nlog NormalizedLog, is
 
 	return nil
 }
+
+// ParserDoc represents a parser document stored in MongoDB.
+type ParserDoc struct {
+	ID              bson.ObjectID                    `bson:"_id,omitempty" json:"id"`
+	Name            string                           `bson:"name" json:"name"`
+	Hash            string                           `bson:"hash" json:"hash"`
+	Pattern         string                           `bson:"pattern" json:"pattern"`
+	Mapping         map[string]string                `bson:"mapping" json:"mapping"`
+	Transformations map[string]parser.Transformation `bson:"transformations,omitempty" json:"transformations,omitempty"`
+	Status          string                           `bson:"status" json:"status"`
+	Format          string                           `bson:"format" json:"format"`
+	Vendor          string                           `bson:"vendor,omitempty" json:"vendor,omitempty"`
+	Product         string                           `bson:"product,omitempty" json:"product,omitempty"`
+	Template        string                           `bson:"template,omitempty" json:"template,omitempty"`
+	Delimiter       string                           `bson:"delimiter,omitempty" json:"delimiter,omitempty"`
+	ExtractedFields []string                         `bson:"extractedFields,omitempty" json:"extractedFields,omitempty"`
+	FieldSignatures []map[string]string              `bson:"fieldSignatures,omitempty" json:"fieldSignatures,omitempty"`
+	SampleLog       string                           `bson:"sampleLog,omitempty" json:"sampleLog,omitempty"`
+	LogsProcessed   int64                            `bson:"logsProcessed" json:"logsProcessed"`
+	LastUsed        time.Time                        `bson:"lastUsed" json:"lastUsed"`
+	CreatedAt       time.Time                        `bson:"createdAt" json:"createdAt"`
+	UpdatedAt       time.Time                        `bson:"updatedAt" json:"updatedAt"`
+}
+
+// SaveParser inserts or updates a parser in MongoDB by Hash.
+func (m *MongoDB) SaveParser(ctx context.Context, p *ParserDoc) (*ParserDoc, error) {
+	collection := m.Collections[CollectionParsers]
+	now := time.Now()
+
+	if p.Name == "" {
+		if p.Product != "" {
+			p.Name = p.Product + "Parser"
+		} else if p.Vendor != "" {
+			p.Name = p.Vendor + "Parser"
+		} else if p.Format != "" && p.Format != "unknown" {
+			p.Name = p.Format + "Parser"
+		} else if len(p.Hash) >= 8 {
+			p.Name = "Parser-" + p.Hash[:8]
+		} else {
+			p.Name = "CustomParser"
+		}
+	}
+	if p.Status == "" {
+		p.Status = "Active"
+	}
+	if p.Format == "" {
+		p.Format = "Custom"
+	}
+
+	var existing ParserDoc
+	err := collection.FindOne(ctx, bson.M{"hash": p.Hash}).Decode(&existing)
+	if err == nil {
+		// Update existing
+		updateFields := bson.M{
+			"pattern":         p.Pattern,
+			"mapping":         p.Mapping,
+			"transformations": p.Transformations,
+			"format":          p.Format,
+			"updatedAt":       now,
+		}
+		if p.Vendor != "" {
+			updateFields["vendor"] = p.Vendor
+		}
+		if p.Product != "" {
+			updateFields["product"] = p.Product
+		}
+		if p.Template != "" {
+			updateFields["template"] = p.Template
+		}
+		if p.Delimiter != "" {
+			updateFields["delimiter"] = p.Delimiter
+		}
+		if len(p.ExtractedFields) > 0 {
+			updateFields["extractedFields"] = p.ExtractedFields
+		}
+		if len(p.FieldSignatures) > 0 {
+			updateFields["fieldSignatures"] = p.FieldSignatures
+		}
+		if p.SampleLog != "" {
+			updateFields["sampleLog"] = p.SampleLog
+		}
+		// If existing parser had a custom name, preserve it unless explicitly overwritten
+		if existing.Name != "" && (p.Name == "" || p.Name == "CustomParser" || (len(p.Hash) >= 8 && p.Name == "Parser-"+p.Hash[:8])) {
+			p.Name = existing.Name
+		} else if p.Name != "" {
+			updateFields["name"] = p.Name
+		}
+		if p.Status != "" {
+			updateFields["status"] = p.Status
+		}
+
+		_, err = collection.UpdateOne(ctx, bson.M{"_id": existing.ID}, bson.M{"$set": updateFields})
+		if err != nil {
+			return nil, err
+		}
+		existing.Pattern = p.Pattern
+		existing.Mapping = p.Mapping
+		existing.Transformations = p.Transformations
+		existing.Format = p.Format
+		existing.Vendor = p.Vendor
+		existing.Product = p.Product
+		existing.Template = p.Template
+		existing.Delimiter = p.Delimiter
+		existing.ExtractedFields = p.ExtractedFields
+		existing.FieldSignatures = p.FieldSignatures
+		existing.UpdatedAt = now
+		if p.SampleLog != "" {
+			existing.SampleLog = p.SampleLog
+		}
+		return &existing, nil
+	}
+
+	// Insert new
+	p.ID = bson.NewObjectID()
+	p.CreatedAt = now
+	p.UpdatedAt = now
+	p.LastUsed = now
+
+	_, err = collection.InsertOne(ctx, p)
+	if err != nil {
+		return nil, err
+	}
+
+	return p, nil
+}
+
+// FindParserByHash finds a parser by its hash.
+func (m *MongoDB) FindParserByHash(ctx context.Context, hash string) (*ParserDoc, error) {
+	collection := m.Collections[CollectionParsers]
+	var p ParserDoc
+	err := collection.FindOne(ctx, bson.M{"hash": hash}).Decode(&p)
+	if err != nil {
+		return nil, err
+	}
+	return &p, nil
+}
+
+// FindParserByID finds a parser by its ObjectID.
+func (m *MongoDB) FindParserByID(ctx context.Context, id bson.ObjectID) (*ParserDoc, error) {
+	collection := m.Collections[CollectionParsers]
+	var p ParserDoc
+	err := collection.FindOne(ctx, bson.M{"_id": id}).Decode(&p)
+	if err != nil {
+		return nil, err
+	}
+	return &p, nil
+}
+
+// FindAllParsers retrieves all parsers.
+func (m *MongoDB) FindAllParsers(ctx context.Context) ([]ParserDoc, error) {
+	collection := m.Collections[CollectionParsers]
+	cursor, err := collection.Find(ctx, bson.M{})
+	if err != nil {
+		return nil, err
+	}
+	defer cursor.Close(ctx)
+
+	var parsers []ParserDoc
+	for cursor.Next(ctx) {
+		var p ParserDoc
+		if err := cursor.Decode(&p); err != nil {
+			return nil, err
+		}
+		parsers = append(parsers, p)
+	}
+
+	if err := cursor.Err(); err != nil {
+		return nil, err
+	}
+
+	if parsers == nil {
+		parsers = []ParserDoc{}
+	}
+
+	return parsers, nil
+}
+
+// UpdateParser updates parser name, format, or status by ID.
+func (m *MongoDB) UpdateParser(ctx context.Context, id bson.ObjectID, name, format, status string) (*ParserDoc, error) {
+	collection := m.Collections[CollectionParsers]
+	update := bson.M{"updatedAt": time.Now()}
+
+	if name != "" {
+		update["name"] = name
+	}
+	if format != "" {
+		update["format"] = format
+	}
+	if status != "" {
+		update["status"] = status
+	}
+
+	_, err := collection.UpdateOne(ctx, bson.M{"_id": id}, bson.M{"$set": update})
+	if err != nil {
+		return nil, err
+	}
+
+	return m.FindParserByID(ctx, id)
+}
+
+// IncrementParserLogsProcessed increments logsProcessed count and sets lastUsed timestamp.
+func (m *MongoDB) IncrementParserLogsProcessed(ctx context.Context, hash string) error {
+	collection := m.Collections[CollectionParsers]
+	_, err := collection.UpdateOne(
+		ctx,
+		bson.M{"hash": hash},
+		bson.M{
+			"$inc": bson.M{"logsProcessed": 1},
+			"$set": bson.M{"lastUsed": time.Now()},
+		},
+	)
+	return err
+}
+
diff --git a/code/backend/internal/parsergen/parser_generator.go b/code/backend/internal/parsergen/parser_generator.go
index 0034f70..6a95445 100644
--- a/code/backend/internal/parsergen/parser_generator.go
+++ b/code/backend/internal/parsergen/parser_generator.go
@@ -116,7 +116,52 @@ func (pg *ParserGenerator) ProcessMessage(ctx context.Context, body []byte) erro
 		return fmt.Errorf("failed to generate parser from ML service: %w", err)
 	}
 
-	// 4. Save parser to Redis/storage
+	// 4. Save parser to MongoDB & Redis/storage
+	if newParser != nil && pg.Reqs != nil {
+		formatName := "Custom"
+		if msg.Features.Format != "" && msg.Features.Format != "unknown" {
+			formatName = string(msg.Features.Format)
+		}
+
+		var signatures []map[string]string
+		for _, sig := range msg.Features.FieldSignatures {
+			signatures = append(signatures, map[string]string{
+				"key":  sig.Key,
+				"type": string(sig.Type),
+			})
+		}
+
+		var extracted []string
+		if len(msg.Features.Keys) > 0 {
+			extracted = msg.Features.Keys
+		} else {
+			for k := range newParser.Mapping {
+				extracted = append(extracted, k)
+			}
+		}
+
+		doc := database.ParserDoc{
+			Hash:            msg.Hash,
+			Pattern:         newParser.Pattern,
+			Mapping:         newParser.Mapping,
+			Transformations: newParser.Transformations,
+			Status:          "Active",
+			Format:          formatName,
+			Vendor:          msg.Features.VendorHint,
+			Product:         msg.Features.ProductHint,
+			Template:        msg.Features.Template,
+			Delimiter:       msg.Features.Delimiter,
+			ExtractedFields: extracted,
+			FieldSignatures: signatures,
+			SampleLog:       msg.RawLog,
+		}
+		if _, dbErr := pg.Reqs.SaveParser(ctx, &doc); dbErr != nil {
+			log.Printf("ParserGenerator: warning: failed to save parser to MongoDB for hash %s: %v", msg.Hash, dbErr)
+		} else {
+			log.Printf("ParserGenerator: successfully saved parser to MongoDB for hash %s", msg.Hash)
+		}
+	}
+
 	if pg.Redis != nil && pg.Redis.Client != nil && newParser != nil {
 		parserJSON, err := json.Marshal(newParser)
 		if err == nil {
diff --git a/code/backend/internal/worker/worker.go b/code/backend/internal/worker/worker.go
index e1c51d7..cb8bc87 100644
--- a/code/backend/internal/worker/worker.go
+++ b/code/backend/internal/worker/worker.go
@@ -100,6 +100,24 @@ func (w *Worker) processJob(ctx context.Context, jobID bson.ObjectID) error {
 		}
 	}
 
+	// 4b. If missing in Redis, check MongoDB parsers collection
+	if p == nil && w.Reqs != nil {
+		doc, err := w.Reqs.FindParserByHash(ctx, hash)
+		if err == nil && doc != nil && doc.Pattern != "" {
+			p = &parser.Parser{
+				Pattern:         doc.Pattern,
+				Mapping:         doc.Mapping,
+				Transformations: doc.Transformations,
+			}
+			log.Printf("Parser found in MongoDB for hash %s, caching in Redis", hash)
+			if w.Redis != nil && w.Redis.Client != nil {
+				if parserJSON, err := json.Marshal(p); err == nil {
+					_ = w.Redis.Client.Set(ctx, redisKey, parserJSON, 0).Err()
+				}
+			}
+		}
+	}
+
 	// 5. If parser doesn't exist:
 	//    - mark fingerprint as PENDING atomically
 	//    - only the worker that successfully creates PENDING publishes a RabbitMQ parser-generation job
@@ -177,6 +195,9 @@ func (w *Worker) processJob(ctx context.Context, jobID bson.ObjectID) error {
 		return fmt.Errorf("failed to insert normalized log to database for %v: %w", jobID, err)
 	}
 
+	// Increment processed logs count for this parser in MongoDB
+	_ = w.Reqs.IncrementParserLogsProcessed(ctx, hash)
+
 	// 8. Update request status to "completed"
 	err = w.Reqs.UpdateReqStatus(ctx, jobID, database.StatusCompleted)
 	if err != nil {
diff --git a/code/frontend/gologgo-client/app/api/parsers/[id]/route.js b/code/frontend/gologgo-client/app/api/parsers/[id]/route.js
new file mode 100644
index 0000000..78c0df9
--- /dev/null
+++ b/code/frontend/gologgo-client/app/api/parsers/[id]/route.js
@@ -0,0 +1,66 @@
+import { NextResponse } from 'next/server';
+
+const BACKEND_URL = process.env.BACKEND_URL || 'http://localhost:8080';
+
+export async function GET(request, { params }) {
+  try {
+    const { id } = await params;
+
+    const backendRes = await fetch(`${BACKEND_URL}/parsers/${id}`, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      cache: 'no-store',
+    });
+
+    if (!backendRes.ok) {
+      const errorText = await backendRes.text();
+      return NextResponse.json(
+        { error: 'Failed to fetch parser', details: errorText },
+        { status: backendRes.status }
+      );
+    }
+
+    const data = await backendRes.json();
+    return NextResponse.json(data);
+  } catch (error) {
+    console.error('Error fetching parser:', error);
+    return NextResponse.json(
+      { error: 'Internal Server Error', details: error.message },
+      { status: 500 }
+    );
+  }
+}
+
+export async function PATCH(request, { params }) {
+  try {
+    const { id } = await params;
+    const body = await request.json();
+
+    const backendRes = await fetch(`${BACKEND_URL}/parsers/${id}`, {
+      method: 'PATCH',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!backendRes.ok) {
+      const errorText = await backendRes.text();
+      return NextResponse.json(
+        { error: 'Failed to update parser', details: errorText },
+        { status: backendRes.status }
+      );
+    }
+
+    const data = await backendRes.json();
+    return NextResponse.json(data);
+  } catch (error) {
+    console.error('Error updating parser:', error);
+    return NextResponse.json(
+      { error: 'Internal Server Error', details: error.message },
+      { status: 500 }
+    );
+  }
+}
diff --git a/code/frontend/gologgo-client/app/api/parsers/route.js b/code/frontend/gologgo-client/app/api/parsers/route.js
new file mode 100644
index 0000000..d430a92
--- /dev/null
+++ b/code/frontend/gologgo-client/app/api/parsers/route.js
@@ -0,0 +1,63 @@
+import { NextResponse } from 'next/server';
+
+const BACKEND_URL = process.env.BACKEND_URL || 'http://localhost:8080';
+
+export async function GET() {
+  try {
+    const backendRes = await fetch(`${BACKEND_URL}/parsers`, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      cache: 'no-store',
+    });
+
+    if (!backendRes.ok) {
+      const errorText = await backendRes.text();
+      return NextResponse.json(
+        { error: 'Failed to fetch parsers from backend', details: errorText },
+        { status: backendRes.status }
+      );
+    }
+
+    const data = await backendRes.json();
+    return NextResponse.json(data);
+  } catch (error) {
+    console.error('Error fetching parsers:', error);
+    return NextResponse.json(
+      { error: 'Internal Server Error', details: error.message },
+      { status: 500 }
+    );
+  }
+}
+
+export async function POST(request) {
+  try {
+    const body = await request.json();
+
+    const backendRes = await fetch(`${BACKEND_URL}/parsers`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!backendRes.ok) {
+      const errorText = await backendRes.text();
+      return NextResponse.json(
+        { error: 'Failed to create parser', details: errorText },
+        { status: backendRes.status }
+      );
+    }
+
+    const data = await backendRes.json();
+    return NextResponse.json(data, { status: 201 });
+  } catch (error) {
+    console.error('Error creating parser:', error);
+    return NextResponse.json(
+      { error: 'Internal Server Error', details: error.message },
+      { status: 500 }
+    );
+  }
+}
diff --git a/code/frontend/gologgo-client/components/parsers-page.jsx b/code/frontend/gologgo-client/components/parsers-page.jsx
index 288584d..d0fc9f8 100644
--- a/code/frontend/gologgo-client/components/parsers-page.jsx
+++ b/code/frontend/gologgo-client/components/parsers-page.jsx
@@ -1,9 +1,21 @@
 'use client'
 
-import { useMemo, useState } from 'react'
+import { useEffect, useMemo, useState } from 'react'
 import { Sidebar } from '@/components/sidebar'
-import { useRouter } from 'next/navigation'
-import { ChevronDown, CircleHelp, FileJson, LayoutDashboard, ListFilter, Menu, Plus, Search, TerminalSquare, X } from 'lucide-react'
+import {
+  ChevronDown,
+  ChevronLeft,
+  ChevronRight,
+  Check,
+  Copy,
+  Edit2,
+  FileJson,
+  Menu,
+  Plus,
+  RefreshCw,
+  Search,
+  X
+} from 'lucide-react'
 import { ThemeToggle } from '@/components/theme-toggle'
 import { Badge } from '@/components/ui/badge'
 import { Button } from '@/components/ui/button'
@@ -11,36 +23,885 @@ import { Card, CardContent } from '@/components/ui/card'
 import { Input } from '@/components/ui/input'
 import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '@/components/ui/table'
 
+function formatTimeAgo(dateInput) {
+  if (!dateInput) return '—'
+  const date = new Date(dateInput)
+  if (isNaN(date.getTime())) return '—'
+  const now = new Date()
+  const diffSeconds = Math.floor((now - date) / 1000)
 
-const parsers = [
-  { name: 'AuthParser', format: 'Authentication', status: 'Active', logs: '5,241', lastUsed: 'Just now', created: 'Aug 20, 2026' },
-  { name: 'NginxParser', format: 'Nginx', status: 'Active', logs: '8,421', lastUsed: '2 min ago', created: 'Aug 18, 2026' },
-  { name: 'PaymentParser', format: 'Payment', status: 'Active', logs: '4,120', lastUsed: '5 min ago', created: 'Aug 22, 2026' },
-  { name: 'PostgresParser', format: 'PostgreSQL', status: 'Active', logs: '3,241', lastUsed: '8 min ago', created: 'Aug 15, 2026' },
-  { name: 'UserParser', format: 'User Activity', status: 'Active', logs: '1,698', lastUsed: '12 min ago', created: 'Aug 21, 2026' },
-  { name: 'GatewayParser', format: 'Gateway Security', status: 'Active', logs: '780', lastUsed: '18 min ago', created: 'Aug 28, 2026' },
-  { name: 'LegacyParser', format: 'Legacy Application', status: 'Inactive', logs: '391', lastUsed: '2 days ago', created: 'Aug 02, 2026' },
-  { name: 'SecurityParser', format: 'Security Event', status: 'Active', logs: '612', lastUsed: '25 min ago', created: 'Aug 27, 2026' },
-]
-
+  if (diffSeconds < 60) return 'Just now'
+  if (diffSeconds < 3600) return `${Math.floor(diffSeconds / 60)} min ago`
+  if (diffSeconds < 86400) return `${Math.floor(diffSeconds / 3600)} hr ago`
+  if (diffSeconds < 604800) return `${Math.floor(diffSeconds / 86400)} days ago`
+  return date.toLocaleDateString('en-US', { month: 'short', day: 'numeric', year: 'numeric' })
+}
 
+function formatDate(dateInput) {
+  if (!dateInput) return '—'
+  const date = new Date(dateInput)
+  if (isNaN(date.getTime())) return '—'
+  return date.toLocaleDateString('en-US', { month: 'short', day: 'numeric', year: 'numeric' })
+}
 
 function SelectFilter({ label, value, onChange, options }) {
-  return <label className="relative flex min-w-32 items-center"><span className="sr-only">{label}</span><select aria-label={label} value={value} onChange={(event) => onChange(event.target.value)} className="h-9 w-full appearance-none rounded-md border border-input bg-background px-3 pr-8 text-xs text-foreground outline-none focus:ring-1 focus:ring-ring">{options.map((option) => <option key={option}>{option}</option>)}</select><ChevronDown className="pointer-events-none absolute right-2.5 size-3.5 text-muted-foreground" /></label>
+  return (
+    <label className="relative flex min-w-32 items-center">
+      <span className="sr-only">{label}</span>
+      <select
+        aria-label={label}
+        value={value}
+        onChange={(event) => onChange(event.target.value)}
+        className="h-9 w-full appearance-none rounded-md border border-input bg-background px-3 pr-8 text-xs text-foreground outline-none transition-colors focus:ring-1 focus:ring-ring"
+      >
+        {options.map((option) => (
+          <option key={option} value={option}>
+            {option}
+          </option>
+        ))}
+      </select>
+      <ChevronDown className="pointer-events-none absolute right-2.5 size-3.5 text-muted-foreground" />
+    </label>
+  )
 }
 
 export function ParsersPage() {
+  const [parsersList, setParsersList] = useState([])
+  const [metrics, setMetrics] = useState({ totalParsers: 0, activeParsers: 0, totalLogsProcessed: 0 })
+  const [loading, setLoading] = useState(true)
+  const [refreshing, setRefreshing] = useState(false)
+  const [error, setError] = useState(null)
+
+  // Filters & Search
   const [search, setSearch] = useState('')
   const [status, setStatus] = useState('All')
   const [format, setFormat] = useState('All Formats')
   const [mobileOpen, setMobileOpen] = useState(false)
-  const router = useRouter()
-  const filtered = useMemo(() => parsers.filter((parser) => `${parser.name} ${parser.format}`.toLowerCase().includes(search.toLowerCase()) && (status === 'All' || parser.status === status) && (format === 'All Formats' || parser.format === format)), [search, status, format])
-  const clear = () => { setSearch(''); setStatus('All'); setFormat('All Formats') }
-
-  return <div className="min-h-screen bg-background text-foreground"><div className="fixed inset-y-0 left-0 hidden md:flex"><Sidebar /></div>{mobileOpen && <div className="fixed inset-0 z-50 flex md:hidden"><button className="absolute inset-0 bg-background/80" onClick={() => setMobileOpen(false)} aria-label="Close navigation" /><div className="relative"><Sidebar onClose={() => setMobileOpen(false)} /></div></div>}<main className="md:pl-60"><div className="mx-auto max-w-[1500px] px-5 py-5 sm:px-8 sm:py-7"><header className="mb-7 flex items-start justify-between gap-4"><div className="flex items-start gap-3"><Button variant="ghost" size="icon" className="mt-0.5 size-9 md:hidden" onClick={() => setMobileOpen(true)} aria-label="Open menu"><Menu /></Button><div><p className="font-mono text-xs uppercase tracking-widest text-muted-foreground">Workspace</p><h1 className="mt-1 text-2xl font-semibold tracking-tight">Parsers</h1><p className="mt-1 text-sm text-muted-foreground">Manage and monitor available log parsers</p></div></div><div className="flex items-center gap-2"><ThemeToggle /><Button size="sm" className="gap-2"><Plus className="size-3.5" />Create Parser</Button></div></header>
-    <section aria-label="Parser metrics" className="mb-5 grid grid-cols-1 gap-3 sm:grid-cols-3"><Card className="py-4"><CardContent className="px-4"><p className="text-xs text-muted-foreground">TOTAL PARSERS</p><p className="mt-2 font-mono text-xl font-medium">12</p></CardContent></Card><Card className="py-4"><CardContent className="px-4"><p className="text-xs text-muted-foreground">ACTIVE PARSERS</p><p className="mt-2 font-mono text-xl font-medium">11</p></CardContent></Card><Card className="py-4"><CardContent className="px-4"><p className="text-xs text-muted-foreground">LOGS PROCESSED</p><p className="mt-2 font-mono text-xl font-medium">23,891</p></CardContent></Card></section>
-    <section aria-label="Parser filters" className="mb-4 flex flex-col gap-3 rounded-lg border border-border bg-card/40 p-3 sm:flex-row sm:items-center"><div className="relative min-w-56 flex-1"><Search className="absolute left-3 top-2.5 size-4 text-muted-foreground" /><Input value={search} onChange={(event) => setSearch(event.target.value)} placeholder="Search parsers..." className="h-9 border-input bg-background pl-9 text-sm" /></div><div className="flex flex-wrap items-center gap-2"><SelectFilter label="Status" value={status} onChange={setStatus} options={['All', 'Active', 'Inactive']} /><SelectFilter label="Format" value={format} onChange={setFormat} options={['All Formats', ...Array.from(new Set(parsers.map((parser) => parser.format)))]} /><Button variant="ghost" size="sm" className="text-xs text-muted-foreground" onClick={clear}>Clear filters</Button></div></section>
-    <Card><CardContent className="p-0"><div className="overflow-x-auto"><Table><TableHeader><TableRow><TableHead>PARSER</TableHead><TableHead>FORMAT</TableHead><TableHead>STATUS</TableHead><TableHead>LOGS PROCESSED</TableHead><TableHead>LAST USED</TableHead><TableHead>CREATED</TableHead><TableHead className="text-right">ACTION</TableHead></TableRow></TableHeader><TableBody>{filtered.map((parser) => <TableRow key={parser.name} tabIndex={0} className="cursor-pointer" onClick={() => router.push(`/parsers/${parser.name.toLowerCase()}`)} onKeyDown={(event) => { if (event.key === 'Enter' || event.key === ' ') router.push(`/parsers/${parser.name.toLowerCase()}`) }}><TableCell className="font-mono text-xs font-medium">{parser.name}</TableCell><TableCell className="text-sm text-muted-foreground">{parser.format}</TableCell><TableCell><Badge variant="outline" className={parser.status === 'Active' ? 'border-emerald-500/30 text-emerald-400' : 'border-border text-muted-foreground'}><span className={`mr-1.5 inline-block size-1.5 rounded-full ${parser.status === 'Active' ? 'bg-emerald-400' : 'bg-muted-foreground'}`} />{parser.status}</Badge></TableCell><TableCell className="font-mono text-xs">{parser.logs}</TableCell><TableCell className="text-sm text-muted-foreground">{parser.lastUsed}</TableCell><TableCell className="text-sm text-muted-foreground">{parser.created}</TableCell><TableCell className="text-right"><span className="text-xs text-muted-foreground">View <span aria-hidden="true">→</span></span></TableCell></TableRow>)}</TableBody></Table></div><div className="border-t border-border px-5 py-3 text-xs text-muted-foreground">Showing 1–{filtered.length} of 12 parsers</div></CardContent></Card>
-  </div></main></div>
+  const [currentPage, setCurrentPage] = useState(1)
+  const [pageSize, setPageSize] = useState(10)
+
+  // Modals
+  const [editingParser, setEditingParser] = useState(null)
+  const [newName, setNewName] = useState('')
+  const [newFormat, setNewFormat] = useState('')
+  const [newStatus, setNewStatus] = useState('Active')
+  const [savingEdit, setSavingEdit] = useState(false)
+
+  const [inspectParser, setInspectParser] = useState(null)
+  const [copiedHash, setCopiedHash] = useState(false)
+  const [copiedPattern, setCopiedPattern] = useState(false)
+
+  const [createModalOpen, setCreateModalOpen] = useState(false)
+  const [createForm, setCreateForm] = useState({
+    name: '',
+    format: '',
+    pattern: '',
+    sampleLog: '',
+    status: 'Active',
+  })
+  const [creating, setCreating] = useState(false)
+
+  // Fetch parsers from API
+  const fetchParsers = async (isManualRefresh = false) => {
+    if (isManualRefresh) setRefreshing(true)
+    else setLoading(true)
+    setError(null)
+
+    try {
+      const res = await fetch('/api/parsers', { cache: 'no-store' })
+      if (!res.ok) {
+        throw new Error(`Failed to load parsers (${res.status})`)
+      }
+      const data = await res.json()
+      const list = data.parsers || []
+      setParsersList(list)
+
+      if (data.metrics) {
+        setMetrics(data.metrics)
+      } else {
+        const active = list.filter((p) => (p.status || 'Active').toLowerCase() === 'active').length
+        const totalLogs = list.reduce((acc, p) => acc + (p.logsProcessed || 0), 0)
+        setMetrics({
+          totalParsers: list.length,
+          activeParsers: active,
+          totalLogsProcessed: totalLogs,
+        })
+      }
+    } catch (err) {
+      console.error('Error fetching parsers:', err)
+      setError(err.message || 'Failed to connect to backend server')
+    } finally {
+      setLoading(false)
+      setRefreshing(false)
+    }
+  }
+
+  useEffect(() => {
+    fetchParsers()
+  }, [])
+
+  // Available format filters from actual dataset
+  const formatOptions = useMemo(() => {
+    const formats = new Set(
+      parsersList.map((p) => p.format || 'Custom').filter(Boolean)
+    )
+    return ['All Formats', ...Array.from(formats)]
+  }, [parsersList])
+
+  // Filtered parsers list
+  const filtered = useMemo(() => {
+    setCurrentPage(1)
+    return parsersList.filter((parser) => {
+      const name = parser.name || ''
+      const fmt = parser.format || 'Custom'
+      const vendor = parser.vendor || ''
+      const product = parser.product || ''
+      const hash = parser.hash || ''
+      const pattern = parser.pattern || ''
+      const sample = parser.sampleLog || ''
+      const parserStatus = parser.status || 'Active'
+      const fields = (parser.extractedFields || Object.keys(parser.mapping || {})).join(' ')
+
+      const matchesSearch =
+        `${name} ${fmt} ${vendor} ${product} ${hash} ${pattern} ${sample} ${fields}`
+          .toLowerCase()
+          .includes(search.toLowerCase())
+      const matchesStatus = status === 'All' || parserStatus.toLowerCase() === status.toLowerCase()
+      const matchesFormat = format === 'All Formats' || fmt.toLowerCase() === format.toLowerCase()
+
+      return matchesSearch && matchesStatus && matchesFormat
+    })
+  }, [parsersList, search, status, format])
+
+  const totalPages = Math.ceil(filtered.length / pageSize)
+  const paginated = filtered.slice((currentPage - 1) * pageSize, currentPage * pageSize)
+
+  const clear = () => {
+    setSearch('')
+    setStatus('All')
+    setFormat('All Formats')
+  }
+
+  // Handle Edit / Rename
+  const openEditModal = (p, e) => {
+    e?.stopPropagation()
+    setEditingParser(p)
+    setNewName(p.name || '')
+    setNewFormat(p.format || 'Custom')
+    setNewStatus(p.status || 'Active')
+  }
+
+  const handleSaveEdit = async (e) => {
+    e.preventDefault()
+    if (!editingParser) return
+    setSavingEdit(true)
+
+    const parserId = editingParser.id || editingParser.hash
+    try {
+      const res = await fetch(`/api/parsers/${parserId}`, {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          name: newName.trim() || editingParser.name,
+          format: newFormat.trim() || editingParser.format,
+          status: newStatus,
+        }),
+      })
+
+      if (!res.ok) {
+        const errorData = await res.json().catch(() => ({}))
+        throw new Error(errorData.error || 'Failed to update parser')
+      }
+
+      setParsersList((prev) =>
+        prev.map((p) => {
+          if ((p.id && p.id === editingParser.id) || (p.hash && p.hash === editingParser.hash)) {
+            return {
+              ...p,
+              name: newName.trim() || p.name,
+              format: newFormat.trim() || p.format,
+              status: newStatus,
+              updatedAt: new Date().toISOString(),
+            }
+          }
+          return p
+        })
+      )
+      if (
+        inspectParser &&
+        ((inspectParser.id && inspectParser.id === editingParser.id) ||
+          inspectParser.hash === editingParser.hash)
+      ) {
+        setInspectParser((prev) => ({
+          ...prev,
+          name: newName.trim() || prev.name,
+          format: newFormat.trim() || prev.format,
+          status: newStatus,
+        }))
+      }
+      setEditingParser(null)
+    } catch (err) {
+      alert(`Error updating parser: ${err.message}`)
+    } finally {
+      setSavingEdit(false)
+    }
+  }
+
+  // Handle Create Parser
+  const handleCreateParser = async (e) => {
+    e.preventDefault()
+    if (!createForm.pattern) {
+      alert('Regex pattern is required')
+      return
+    }
+    setCreating(true)
+
+    try {
+      const res = await fetch('/api/parsers', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          name: createForm.name.trim() || undefined,
+          format: createForm.format.trim() || 'Custom',
+          pattern: createForm.pattern.trim(),
+          sampleLog: createForm.sampleLog.trim() || undefined,
+          status: createForm.status || 'Active',
+        }),
+      })
+
+      if (!res.ok) {
+        const errorData = await res.json().catch(() => ({}))
+        throw new Error(errorData.error || 'Failed to create parser')
+      }
+
+      setCreateModalOpen(false)
+      setCreateForm({ name: '', format: '', pattern: '', sampleLog: '', status: 'Active' })
+      fetchParsers(true)
+    } catch (err) {
+      alert(`Error creating parser: ${err.message}`)
+    } finally {
+      setCreating(false)
+    }
+  }
+
+  const copyToClipboard = (text, type = 'hash') => {
+    navigator.clipboard.writeText(text)
+    if (type === 'hash') {
+      setCopiedHash(true)
+      setTimeout(() => setCopiedHash(false), 2000)
+    } else {
+      setCopiedPattern(true)
+      setTimeout(() => setCopiedPattern(false), 2000)
+    }
+  }
+
+  return (
+    <div className="min-h-screen bg-background text-foreground">
+      {/* Sidebar Desktop */}
+      <div className="fixed inset-y-0 left-0 hidden md:flex">
+        <Sidebar />
+      </div>
+
+      {/* Sidebar Mobile */}
+      {mobileOpen && (
+        <div className="fixed inset-0 z-50 flex md:hidden">
+          <button
+            className="absolute inset-0 bg-background/80 backdrop-blur-sm"
+            onClick={() => setMobileOpen(false)}
+            aria-label="Close navigation"
+          />
+          <div className="relative">
+            <Sidebar onClose={() => setMobileOpen(false)} />
+          </div>
+        </div>
+      )}
+
+      {/* Main Content Area */}
+      <main className="md:pl-60">
+        <div className="mx-auto max-w-[1500px] px-5 py-5 sm:px-8 sm:py-7">
+          {/* Header */}
+          <header className="mb-7 flex items-start justify-between gap-4">
+            <div className="flex items-start gap-3">
+              <Button
+                variant="ghost"
+                size="icon"
+                className="mt-0.5 size-9 md:hidden"
+                onClick={() => setMobileOpen(true)}
+                aria-label="Open menu"
+              >
+                <Menu />
+              </Button>
+              <div>
+                <p className="font-mono text-xs uppercase tracking-widest text-muted-foreground">
+                  Workspace
+                </p>
+                <h1 className="mt-1 text-2xl font-semibold tracking-tight">Parsers</h1>
+                <p className="mt-1 text-sm text-muted-foreground">
+                  Manage and inspect active log parsers and extraction schemas
+                </p>
+              </div>
+            </div>
+
+            <div className="flex items-center gap-2">
+              <ThemeToggle />
+              <Button
+                variant="outline"
+                size="icon"
+                className="size-8"
+                onClick={() => fetchParsers(true)}
+                disabled={loading || refreshing}
+                aria-label="Refresh parsers"
+              >
+                <RefreshCw className={`size-3.5 ${refreshing ? 'animate-spin' : ''}`} />
+              </Button>
+              <Button
+                size="sm"
+                className="gap-2"
+                onClick={() => setCreateModalOpen(true)}
+              >
+                <Plus className="size-3.5" />
+                <span>Create Parser</span>
+              </Button>
+            </div>
+          </header>
+
+          {/* Metrics Section */}
+          <section
+            aria-label="Parser metrics"
+            className="mb-5 grid grid-cols-3 divide-x divide-border rounded-lg border border-border bg-card/40"
+          >
+            <div className="px-4 py-4">
+              <p className="text-[11px] uppercase tracking-wider text-muted-foreground">Total Parsers</p>
+              <p className="mt-1 font-mono text-xl">{loading ? '—' : metrics.totalParsers || parsersList.length}</p>
+            </div>
+            <div className="px-4 py-4">
+              <p className="text-[11px] uppercase tracking-wider text-muted-foreground">Active Parsers</p>
+              <p className="mt-1 font-mono text-xl text-emerald-400">{loading ? '—' : metrics.activeParsers || 0}</p>
+            </div>
+            <div className="px-4 py-4">
+              <p className="text-[11px] uppercase tracking-wider text-muted-foreground">Logs Processed</p>
+              <p className="mt-1 font-mono text-xl">
+                {loading ? '—' : Number(metrics.totalLogsProcessed || 0).toLocaleString()}
+              </p>
+            </div>
+          </section>
+
+          {/* Error Message */}
+          {error && (
+            <div className="mb-5 rounded-lg border border-red-500/20 bg-red-500/10 p-4 text-sm text-red-400">
+              <div className="flex items-center justify-between">
+                <span>{error}</span>
+                <Button size="xs" variant="outline" onClick={() => fetchParsers(true)}>
+                  Retry
+                </Button>
+              </div>
+            </div>
+          )}
+
+          {/* Filters Bar */}
+          <section
+            aria-label="Parser filters"
+            className="mb-5 flex flex-col gap-3 rounded-lg border border-border bg-card/40 p-3"
+          >
+            <div className="relative">
+              <Search className="absolute left-3 top-2.5 size-4 text-muted-foreground" />
+              <Input
+                value={search}
+                onChange={(event) => setSearch(event.target.value)}
+                placeholder="Search parsers by name, format, or fields..."
+                className="h-9 border-input bg-background pl-9 text-sm"
+              />
+            </div>
+            <div className="flex flex-wrap items-center gap-2">
+              <SelectFilter
+                label="Status"
+                value={status}
+                onChange={setStatus}
+                options={['All', 'Active', 'Inactive']}
+              />
+              <SelectFilter
+                label="Format"
+                value={format}
+                onChange={setFormat}
+                options={formatOptions}
+              />
+              {(search || status !== 'All' || format !== 'All Formats') && (
+                <button
+                  onClick={clear}
+                  className="px-2 text-xs text-muted-foreground underline-offset-4 hover:text-foreground hover:underline"
+                >
+                  Clear filters
+                </button>
+              )}
+            </div>
+          </section>
+
+          {/* Clean Parsers Table */}
+          <section className="overflow-hidden rounded-lg border border-border bg-card/20">
+            <div className="flex items-center justify-between border-b border-border px-4 py-3">
+              <div>
+                <h2 className="text-sm font-medium">All Parsers</h2>
+                <p className="mt-0.5 text-xs text-muted-foreground">
+                  {parsersList.length} total parsers in database
+                </p>
+              </div>
+              <span className="font-mono text-xs text-muted-foreground">MongoDB Synced</span>
+            </div>
+
+            <div className="overflow-x-auto">
+              <Table>
+                <TableHeader>
+                  <TableRow className="hover:bg-transparent">
+                    <TableHead className="w-48 pl-4">Parser Name</TableHead>
+                    <TableHead className="w-28">Format</TableHead>
+                    <TableHead className="min-w-48">Extracted Fields</TableHead>
+                    <TableHead className="min-w-64">Sample Log</TableHead>
+                    <TableHead className="w-28">Logs</TableHead>
+                    <TableHead className="w-24">Status</TableHead>
+                    <TableHead className="w-28">Last Used</TableHead>
+                    <TableHead className="w-28 pr-4 text-right">Action</TableHead>
+                  </TableRow>
+                </TableHeader>
+                <TableBody>
+                  {loading ? (
+                    <TableRow>
+                      <TableCell colSpan={8} className="h-32 text-center text-xs text-muted-foreground">
+                        Loading parsers...
+                      </TableCell>
+                    </TableRow>
+                  ) : paginated.length === 0 ? (
+                    <TableRow>
+                      <TableCell colSpan={8} className="h-32 text-center text-xs text-muted-foreground">
+                        No parsers found
+                      </TableCell>
+                    </TableRow>
+                  ) : (
+                    paginated.map((parserItem) => {
+                      const parserName = parserItem.name || 'Unnamed Parser'
+                      const parserFormat = parserItem.format || 'Custom'
+                      const parserStatus = parserItem.status || 'Active'
+                      const isActive = parserStatus.toLowerCase() === 'active'
+                      const fields = parserItem.extractedFields || Object.keys(parserItem.mapping || {})
+
+                      return (
+                        <TableRow
+                          key={parserItem.id || parserItem.hash}
+                          className="cursor-pointer transition-colors hover:bg-accent/50 group"
+                          onClick={() => setInspectParser(parserItem)}
+                        >
+                          {/* Parser Name */}
+                          <TableCell className="pl-4 font-mono text-xs">
+                            <div className="flex items-center gap-1.5">
+                              <span className="font-medium text-foreground">{parserName}</span>
+                              <button
+                                onClick={(e) => openEditModal(parserItem, e)}
+                                className="opacity-0 group-hover:opacity-100 p-0.5 text-muted-foreground hover:text-foreground transition-opacity"
+                                title="Rename Parser"
+                              >
+                                <Edit2 className="size-3" />
+                              </button>
+                            </div>
+                            <span className="text-[10px] text-muted-foreground block truncate max-w-36">
+                              {parserItem.hash ? `${parserItem.hash.slice(0, 12)}...` : ''}
+                            </span>
+                          </TableCell>
+
+                          {/* Format */}
+                          <TableCell>
+                            <Badge variant="outline" className="font-mono text-[10px]">
+                              {parserFormat}
+                            </Badge>
+                          </TableCell>
+
+                          {/* Extracted Fields */}
+                          <TableCell>
+                            <div className="flex flex-wrap items-center gap-1 max-w-[220px]">
+                              {fields.length === 0 ? (
+                                <span className="text-xs text-muted-foreground">—</span>
+                              ) : (
+                                <>
+                                  {fields.slice(0, 3).map((f) => (
+                                    <span
+                                      key={f}
+                                      className="rounded bg-muted px-1.5 py-0.5 font-mono text-[10px] text-muted-foreground"
+                                    >
+                                      {f}
+                                    </span>
+                                  ))}
+                                  {fields.length > 3 && (
+                                    <span className="text-[10px] text-muted-foreground font-mono">
+                                      +{fields.length - 3}
+                                    </span>
+                                  )}
+                                </>
+                              )}
+                            </div>
+                          </TableCell>
+
+                          {/* Sample Log Preview */}
+                          <TableCell className="max-w-xs font-mono text-xs text-muted-foreground truncate">
+                            {parserItem.sampleLog || parserItem.pattern || '—'}
+                          </TableCell>
+
+                          {/* Logs Count */}
+                          <TableCell className="font-mono text-xs">
+                            {Number(parserItem.logsProcessed || 0).toLocaleString()}
+                          </TableCell>
+
+                          {/* Status */}
+                          <TableCell>
+                            <span
+                              className={`inline-flex items-center gap-1.5 text-xs ${
+                                isActive ? 'text-emerald-400' : 'text-muted-foreground'
+                              }`}
+                            >
+                              <span
+                                className={`size-1.5 rounded-full ${
+                                  isActive ? 'bg-emerald-400' : 'bg-muted-foreground'
+                                }`}
+                              />
+                              {parserStatus}
+                            </span>
+                          </TableCell>
+
+                          {/* Last Used */}
+                          <TableCell className="text-xs text-muted-foreground whitespace-nowrap">
+                            {formatTimeAgo(parserItem.lastUsed || parserItem.updatedAt)}
+                          </TableCell>
+
+                          {/* Actions */}
+                          <TableCell className="pr-4 text-right">
+                            <div className="flex items-center justify-end gap-1">
+                              <Button
+                                variant="ghost"
+                                size="sm"
+                                className="h-7 px-2 text-xs text-muted-foreground hover:text-foreground"
+                                onClick={(e) => openEditModal(parserItem, e)}
+                              >
+                                Rename
+                              </Button>
+                              <span className="text-muted-foreground text-xs">›</span>
+                            </div>
+                          </TableCell>
+                        </TableRow>
+                      )
+                    })
+                  )}
+                </TableBody>
+              </Table>
+            </div>
+          </section>
+
+          {/* Pagination Footer */}
+          <div className="flex flex-col gap-4 py-4 text-xs text-muted-foreground sm:flex-row sm:items-center sm:justify-between">
+            <span>
+              Showing {filtered.length === 0 ? 0 : (currentPage - 1) * pageSize + 1}–
+              {Math.min(currentPage * pageSize, filtered.length)} of {filtered.length} parsers
+            </span>
+            <div className="flex items-center gap-1">
+              <Button
+                variant="outline"
+                size="sm"
+                className="h-8 gap-1"
+                disabled={currentPage === 1}
+                onClick={() => setCurrentPage((p) => Math.max(1, p - 1))}
+              >
+                <ChevronLeft className="size-3.5" />
+                Previous
+              </Button>
+              <div className="flex items-center gap-1 mx-2 text-sm font-medium">
+                Page {currentPage} of {totalPages || 1}
+              </div>
+              <Button
+                variant="outline"
+                size="sm"
+                className="h-8 gap-1"
+                disabled={currentPage === totalPages || totalPages === 0}
+                onClick={() => setCurrentPage((p) => Math.min(totalPages, p + 1))}
+              >
+                Next
+                <ChevronRight className="size-3.5" />
+              </Button>
+              <select
+                aria-label="Parsers per page"
+                value={pageSize}
+                onChange={(e) => {
+                  setPageSize(Number(e.target.value))
+                  setCurrentPage(1)
+                }}
+                className="ml-2 h-8 rounded-md border border-input bg-background px-2 text-xs"
+              >
+                <option value={10}>10 per page</option>
+                <option value={25}>25 per page</option>
+                <option value={50}>50 per page</option>
+              </select>
+            </div>
+          </div>
+        </div>
+      </main>
+
+      {/* RENAME / EDIT PARSER MODAL */}
+      {editingParser && (
+        <div className="fixed inset-0 z-50 flex items-center justify-center bg-background/80 backdrop-blur-sm p-4">
+          <div className="relative w-full max-w-md rounded-lg border border-border bg-card p-6 shadow-lg">
+            <div className="flex items-center justify-between border-b border-border pb-3">
+              <h2 className="text-base font-semibold">Rename Parser</h2>
+              <button
+                onClick={() => setEditingParser(null)}
+                className="text-muted-foreground hover:text-foreground"
+              >
+                <X className="size-4" />
+              </button>
+            </div>
+
+            <form onSubmit={handleSaveEdit} className="mt-4 space-y-4 text-xs">
+              <div>
+                <label className="block font-medium mb-1">Parser Name</label>
+                <Input
+                  value={newName}
+                  onChange={(e) => setNewName(e.target.value)}
+                  placeholder="e.g. NginxParser"
+                  className="h-8 text-xs"
+                  autoFocus
+                  required
+                />
+              </div>
+
+              <div className="grid grid-cols-2 gap-3">
+                <div>
+                  <label className="block font-medium mb-1">Format</label>
+                  <Input
+                    value={newFormat}
+                    onChange={(e) => setNewFormat(e.target.value)}
+                    placeholder="e.g. Nginx"
+                    className="h-8 text-xs"
+                  />
+                </div>
+
+                <div>
+                  <label className="block font-medium mb-1">Status</label>
+                  <select
+                    value={newStatus}
+                    onChange={(e) => setNewStatus(e.target.value)}
+                    className="h-8 w-full rounded-md border border-input bg-background px-2 text-xs text-foreground outline-none"
+                  >
+                    <option value="Active">Active</option>
+                    <option value="Inactive">Inactive</option>
+                  </select>
+                </div>
+              </div>
+
+              <div className="flex justify-end gap-2 pt-3 border-t border-border">
+                <Button
+                  type="button"
+                  variant="outline"
+                  size="sm"
+                  onClick={() => setEditingParser(null)}
+                >
+                  Cancel
+                </Button>
+                <Button type="submit" size="sm" disabled={savingEdit}>
+                  Save
+                </Button>
+              </div>
+            </form>
+          </div>
+        </div>
+      )}
+
+      {/* INSPECT DETAILS MODAL */}
+      {inspectParser && (
+        <div className="fixed inset-0 z-50 flex items-center justify-center bg-background/80 backdrop-blur-sm p-4">
+          <div className="relative w-full max-w-2xl rounded-lg border border-border bg-card p-6 shadow-xl max-h-[85vh] overflow-y-auto">
+            <div className="flex items-start justify-between border-b border-border pb-4">
+              <div>
+                <div className="flex items-center gap-2">
+                  <h2 className="text-base font-semibold">{inspectParser.name || 'Parser Details'}</h2>
+                  <Badge variant="outline" className="text-[10px]">
+                    {inspectParser.format || 'Custom'}
+                  </Badge>
+                </div>
+                <p className="text-xs text-muted-foreground mt-0.5">
+                  Fingerprint Hash: <span className="font-mono">{inspectParser.hash || '—'}</span>
+                </p>
+              </div>
+              <button
+                onClick={() => setInspectParser(null)}
+                className="text-muted-foreground hover:text-foreground"
+              >
+                <X className="size-4" />
+              </button>
+            </div>
+
+            <div className="mt-4 space-y-4 text-xs">
+              {/* Sample Log */}
+              {inspectParser.sampleLog && (
+                <div>
+                  <span className="font-medium text-muted-foreground block mb-1">Sample Raw Log</span>
+                  <div className="rounded-md border border-border bg-muted/30 p-2.5 font-mono text-xs text-foreground whitespace-pre-wrap break-all">
+                    {inspectParser.sampleLog}
+                  </div>
+                </div>
+              )}
+
+              {/* Regex Pattern */}
+              <div>
+                <div className="flex items-center justify-between mb-1">
+                  <span className="font-medium text-muted-foreground">Synthesized Regex Pattern</span>
+                  <button
+                    onClick={() => copyToClipboard(inspectParser.pattern, 'pat')}
+                    className="text-[11px] text-muted-foreground hover:text-foreground flex items-center gap-1"
+                  >
+                    {copiedPattern ? <Check className="size-3 text-emerald-400" /> : <Copy className="size-3" />}
+                    <span>{copiedPattern ? 'Copied' : 'Copy'}</span>
+                  </button>
+                </div>
+                <div className="rounded-md border border-border bg-muted/30 p-2.5 font-mono text-xs text-foreground whitespace-pre-wrap break-all">
+                  {inspectParser.pattern || 'No regex pattern defined'}
+                </div>
+              </div>
+
+              {/* Extracted Fields */}
+              <div>
+                <span className="font-medium text-muted-foreground block mb-1">Extracted Fields</span>
+                <div className="flex flex-wrap gap-1.5">
+                  {(inspectParser.extractedFields || Object.keys(inspectParser.mapping || {})).map((f) => (
+                    <span
+                      key={f}
+                      className="rounded border border-border bg-muted/40 px-2 py-1 font-mono text-xs"
+                    >
+                      {f}
+                    </span>
+                  ))}
+                </div>
+              </div>
+
+              {/* Field Mappings */}
+              {inspectParser.mapping && Object.keys(inspectParser.mapping).length > 0 && (
+                <div>
+                  <span className="font-medium text-muted-foreground block mb-1">Field Normalization</span>
+                  <div className="rounded-md border border-border overflow-hidden">
+                    <Table>
+                      <TableHeader>
+                        <TableRow className="hover:bg-transparent">
+                          <TableHead className="text-xs">Extracted Key</TableHead>
+                          <TableHead className="text-xs">Normalized Field</TableHead>
+                        </TableRow>
+                      </TableHeader>
+                      <TableBody>
+                        {Object.entries(inspectParser.mapping).map(([k, v]) => (
+                          <TableRow key={k}>
+                            <TableCell className="font-mono text-xs">{k}</TableCell>
+                            <TableCell className="font-mono text-xs text-muted-foreground">{v}</TableCell>
+                          </TableRow>
+                        ))}
+                      </TableBody>
+                    </Table>
+                  </div>
+                </div>
+              )}
+
+              {/* Metadata */}
+              <div className="grid grid-cols-2 gap-2 pt-2 border-t border-border text-muted-foreground text-xs">
+                <div>
+                  Logs Processed: <span className="text-foreground font-mono">{inspectParser.logsProcessed || 0}</span>
+                </div>
+                <div>
+                  Created: <span className="text-foreground">{formatDate(inspectParser.createdAt)}</span>
+                </div>
+              </div>
+            </div>
+
+            <div className="mt-5 flex justify-end border-t border-border pt-3">
+              <Button
+                variant="outline"
+                size="sm"
+                onClick={() => setInspectParser(null)}
+              >
+                Close
+              </Button>
+            </div>
+          </div>
+        </div>
+      )}
+
+      {/* CREATE PARSER MODAL */}
+      {createModalOpen && (
+        <div className="fixed inset-0 z-50 flex items-center justify-center bg-background/80 backdrop-blur-sm p-4">
+          <div className="relative w-full max-w-md rounded-lg border border-border bg-card p-6 shadow-lg">
+            <div className="flex items-center justify-between border-b border-border pb-3">
+              <h2 className="text-base font-semibold">Create Parser</h2>
+              <button
+                onClick={() => setCreateModalOpen(false)}
+                className="text-muted-foreground hover:text-foreground"
+              >
+                <X className="size-4" />
+              </button>
+            </div>
+
+            <form onSubmit={handleCreateParser} className="mt-4 space-y-3 text-xs">
+              <div className="grid grid-cols-2 gap-3">
+                <div>
+                  <label className="block font-medium mb-1">Parser Name</label>
+                  <Input
+                    value={createForm.name}
+                    onChange={(e) => setCreateForm({ ...createForm, name: e.target.value })}
+                    placeholder="e.g. AuthParser"
+                    className="h-8 text-xs"
+                    required
+                  />
+                </div>
+                <div>
+                  <label className="block font-medium mb-1">Format</label>
+                  <Input
+                    value={createForm.format}
+                    onChange={(e) => setCreateForm({ ...createForm, format: e.target.value })}
+                    placeholder="e.g. Nginx"
+                    className="h-8 text-xs"
+                  />
+                </div>
+              </div>
+
+              <div>
+                <label className="block font-medium mb-1">Regex Pattern *</label>
+                <textarea
+                  value={createForm.pattern}
+                  onChange={(e) => setCreateForm({ ...createForm, pattern: e.target.value })}
+                  placeholder="(?P<timestamp>\S+ \S+) (?P<severity>\w+) (?P<service>[\w-]+) (?P<message>.*)"
+                  rows={3}
+                  className="w-full rounded-md border border-input bg-background p-2 font-mono text-xs text-foreground outline-none focus:ring-1 focus:ring-ring"
+                  required
+                />
+              </div>
+
+              <div>
+                <label className="block font-medium mb-1">Sample Raw Log (Optional)</label>
+                <textarea
+                  value={createForm.sampleLog}
+                  onChange={(e) => setCreateForm({ ...createForm, sampleLog: e.target.value })}
+                  placeholder="2026-09-08 20:15:32 ERROR auth-service User login failed"
+                  rows={2}
+                  className="w-full rounded-md border border-input bg-background p-2 font-mono text-xs text-foreground outline-none focus:ring-1 focus:ring-ring"
+                />
+              </div>
+
+              <div className="flex justify-end gap-2 pt-3 border-t border-border">
+                <Button
+                  type="button"
+                  variant="outline"
+                  size="sm"
+                  onClick={() => setCreateModalOpen(false)}
+                >
+                  Cancel
+                </Button>
+                <Button type="submit" size="sm" disabled={creating}>
+                  Create
+                </Button>
+              </div>
+            </form>
+          </div>
+        </div>
+      )}
+    </div>
+  )
 }
diff --git a/code/frontend/gologgo-client/package-lock.json b/code/frontend/gologgo-client/package-lock.json
index 332b392..fa27c0f 100644
--- a/code/frontend/gologgo-client/package-lock.json
+++ b/code/frontend/gologgo-client/package-lock.json
@@ -866,9 +866,6 @@
       "cpu": [
         "arm"
       ],
-      "libc": [
-        "glibc"
-      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -885,9 +882,6 @@
       "cpu": [
         "arm64"
       ],
-      "libc": [
-        "glibc"
-      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -904,9 +898,6 @@
       "cpu": [
         "ppc64"
       ],
-      "libc": [
-        "glibc"
-      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -923,9 +914,6 @@
       "cpu": [
         "riscv64"
       ],
-      "libc": [
-        "glibc"
-      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -942,9 +930,6 @@
       "cpu": [
         "s390x"
       ],
-      "libc": [
-        "glibc"
-      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -961,9 +946,6 @@
       "cpu": [
         "x64"
       ],
-      "libc": [
-        "glibc"
-      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -980,9 +962,6 @@
       "cpu": [
         "arm64"
       ],
-      "libc": [
-        "musl"
-      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -999,9 +978,6 @@
       "cpu": [
         "x64"
       ],
-      "libc": [
-        "musl"
-      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -1018,9 +994,6 @@
       "cpu": [
         "arm"
       ],
-      "libc": [
-        "glibc"
-      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -1043,9 +1016,6 @@
       "cpu": [
         "arm64"
       ],
-      "libc": [
-        "glibc"
-      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -1068,9 +1038,6 @@
       "cpu": [
         "ppc64"
       ],
-      "libc": [
-        "glibc"
-      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -1093,9 +1060,6 @@
       "cpu": [
         "riscv64"
       ],
-      "libc": [
-        "glibc"
-      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -1118,9 +1082,6 @@
       "cpu": [
         "s390x"
       ],
-      "libc": [
-        "glibc"
-      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -1143,9 +1104,6 @@
       "cpu": [
         "x64"
       ],
-      "libc": [
-        "glibc"
-      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -1168,9 +1126,6 @@
       "cpu": [
         "arm64"
       ],
-      "libc": [
-        "musl"
-      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -1193,9 +1148,6 @@
       "cpu": [
         "x64"
       ],
-      "libc": [
-        "musl"
-      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -1433,9 +1385,6 @@
       "cpu": [
         "arm64"
       ],
-      "libc": [
-        "glibc"
-      ],
       "license": "MIT",
       "optional": true,
       "os": [
@@ -1452,9 +1401,6 @@
       "cpu": [
         "arm64"
       ],
-      "libc": [
-        "musl"
-      ],
       "license": "MIT",
       "optional": true,
       "os": [
@@ -1471,9 +1417,6 @@
       "cpu": [
         "x64"
       ],
-      "libc": [
-        "glibc"
-      ],
       "license": "MIT",
       "optional": true,
       "os": [
@@ -1490,9 +1433,6 @@
       "cpu": [
         "x64"
       ],
-      "libc": [
-        "musl"
-      ],
       "license": "MIT",
       "optional": true,
       "os": [
@@ -1729,9 +1669,6 @@
         "arm64"
       ],
       "dev": true,
-      "libc": [
-        "glibc"
-      ],
       "license": "MIT",
       "optional": true,
       "os": [
@@ -1749,9 +1686,6 @@
         "arm64"
       ],
       "dev": true,
-      "libc": [
-        "musl"
-      ],
       "license": "MIT",
       "optional": true,
       "os": [
@@ -1769,9 +1703,6 @@
         "x64"
       ],
       "dev": true,
-      "libc": [
-        "glibc"
-      ],
       "license": "MIT",
       "optional": true,
       "os": [
@@ -1789,9 +1720,6 @@
         "x64"
       ],
       "dev": true,
-      "libc": [
-        "musl"
-      ],
       "license": "MIT",
       "optional": true,
       "os": [
@@ -3757,9 +3685,6 @@
         "arm64"
       ],
       "dev": true,
-      "libc": [
-        "glibc"
-      ],
       "license": "MPL-2.0",
       "optional": true,
       "os": [
@@ -3781,9 +3706,6 @@
         "arm64"
       ],
       "dev": true,
-      "libc": [
-        "musl"
-      ],
       "license": "MPL-2.0",
       "optional": true,
       "os": [
@@ -3805,9 +3727,6 @@
         "x64"
       ],
       "dev": true,
-      "libc": [
-        "glibc"
-      ],
       "license": "MPL-2.0",
       "optional": true,
       "os": [
@@ -3829,9 +3748,6 @@
         "x64"
       ],
       "dev": true,
-      "libc": [
-        "musl"
-      ],
       "license": "MPL-2.0",
       "optional": true,
       "os": [