diff --git a/.gitignore b/.gitignore
index dfcfd56..8adfde4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,6 +9,7 @@
 *.user
 *.userosscache
 *.sln.docstates
+/vendor/
 
 # User-specific files (MonoDevelop/Xamarin Studio)
 *.userprefs
@@ -348,3 +349,5 @@ MigrationBackup/
 
 # Ionide (cross platform F# VS Code tools) working folder
 .ionide/
+
+/vendor/
diff --git a/Http/Http.php b/Http/Http.php
new file mode 100644
index 0000000..adc81e5
--- /dev/null
+++ b/Http/Http.php
@@ -0,0 +1,101 @@
+<?php 
+
+namespace Md\Http;
+
+
+use function array_map, header, http_response_code, preg_match;
+
+/**
+ * HTTP Operations
+ */
+class Http 
+{
+    /** Current */
+    static private RequestInterface $request;
+
+    static public function getRequest() 
+    {
+        return self::$request = self::$request ?? new Request();
+    }
+
+    static public function setRequest($_request) 
+    {
+        self::$request = $_request;
+    }
+
+    static public function getResponse() 
+    {
+        return self::getRequest()->getResponse();
+    }
+
+
+    /**
+     * Secure data in array
+     * Accept alphanumerics characters only
+     * @return array the input array whitout
+     * @todo Move method outside this class
+     */
+    static public function secure(array $_data = []): array
+    {
+        return array_filter(array_map(function ($v) {
+            $v = basename($v);
+            if(!preg_match("/^[A-Za-z0-9\.\-]*$/", $v)) {
+                self::badRequest('Invalid data');
+            }
+            return $v;
+           // return \preg_replace("/[^a-zA-Z0-9]/", "", \basename(\strip_tags($v), '.php'));
+        }, $_data));
+    }
+
+    static public function end(int $_code = 500, string $data = 'Internal Error'): void 
+    {
+        http_response_code($_code);
+        exit($data);
+    }
+
+    static public function response(ResponseInterface $response): void 
+    {
+        header('Content-Type: ' . $response->getContentType());
+        self::end($response->getCode(), $response->getBody());
+    }
+
+    static public function ok(string $data): void 
+    {        
+        self::end(200, $data);
+    }
+
+    static public function accepted(string $data): void 
+    {
+        self::end(202, $data);
+    }
+
+    static public function badRequest(string $msg = 'Invalid message received'): void 
+    {
+        self::end(400, $msg);
+    }
+
+    static public function unauthorized(string $msg = 'Invalid Token'): void 
+    {
+        self::end(401, $msg);
+    }
+
+    static public function forbidden(string $msg = 'You are not allowed to access this resource'): void 
+    {
+        self::end(403, $msg);
+    }
+
+    static public function notFound(string $msg = 'Not found'): void 
+    {
+        self::end(404, ('No route for '.$_SERVER['REQUEST_URI']. ' ('.$msg.')'));
+    }
+
+    static public function notAllowed(): void 
+    {
+        self::end(405, ('No route for '.$_SERVER['REQUEST_METHOD'].' '.$_SERVER['REQUEST_URI']));
+    }
+
+    static public function notImplemented(): void 
+    {
+        self::end(501, 'Not implemented');
+    }
+}
diff --git a/Http/HttpFactory.php b/Http/HttpFactory.php
new file mode 100644
index 0000000..561bdbf
--- /dev/null
+++ b/Http/HttpFactory.php
@@ -0,0 +1,17 @@
+<?php 
+
+
+namespace Md\Http;
+
+class HttpFactory 
+{
+    static public function createRequest(string $_method, string $_url): RequestInterface
+    {
+        return new Request();
+    }
+
+    static public function createResponse(): ResponseInterface
+    {
+        return new Response();
+    }
+}
diff --git a/Http/Message.php b/Http/Message.php
new file mode 100644
index 0000000..77108d2
--- /dev/null
+++ b/Http/Message.php
@@ -0,0 +1,103 @@
+<?php 
+
+namespace Md\Http;
+
+use function implode, json_encode, mb_convert_case, trim;
+
+/**
+ * Class Message
+ * Represents a HTTP Message
+ */
+class Message implements MessageInterface
+{
+    /** Define a Generic message type */
+    public const DEFAULT = 'application/octet-stream';
+
+    /** Define a JSON message type */
+    public const JSON = 'application/json';
+
+    /** Define a HTML message type */
+    public const HTML = 'text/html';
+
+    /** Define a XML message type */
+    public const XML = 'application/xml';
+
+    /** @var string $contentType The current message content-type */
+    private string $contentType;
+
+    /** @var string $body The current message body */
+    private string $body;
+
+    /** @var string $data The current message body as array */
+    private array $data;
+
+    /**
+     * Initialize a new HTTP Message with specified content-type and empty body
+     * @param string $_contentType The message content-type or Message::DEFAULT if not defined
+     * @param string $_body The message body or empty if not defined
+     */
+    public function __construct(string $_contentType = Message::DEFAULT, string $_body = '') 
+    {
+        $this->withContentType($_contentType)->withBody($_body);
+    }
+
+    /**
+     * Get the current message content-type
+     * @return string The message content-type
+     */
+    public function getContentType(): string 
+    {
+        return $this->contentType;
+    }
+
+    /**
+     * Set the current message content-type
+     * @param string $_contentType The content-type to apply 
+     * @return self
+     */
+    public function withContentType(string $_contentType): MessageInterface 
+    {
+        $this->contentType = mb_convert_case($_contentType, MB_CASE_LOWER);
+        return $this;
+    }
+
+    /**
+     * Get the current message body
+     * @return string The message body
+     */
+    public function getBody(): string 
+    {
+        return $this->body;
+    }
+
+
+    /**
+     * Set the current message body
+     * @param string $_body The message body
+     * @return self
+     */
+    public function withBody(string $_body): MessageInterface 
+    {
+        $this->body = trim($_body);
+        return $this;
+    }
+
+
+    /*public function getData(): array 
+    {
+        return [$this->body];
+    }
+    public function withData(array $_data): MessageInterface
+    {
+        if($this->contentType === Message::JSON) {
+            return $this->withBody(json_encode($_data, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES));
+        }
+
+        $s = [];
+        foreach($_data as $k => $v) {
+            $s[] = ($k.'='.$v);
+        }
+
+        return $this->withBody(implode(";", $s));
+    }*/
+}
diff --git a/Http/MessageInterface.php b/Http/MessageInterface.php
new file mode 100644
index 0000000..55e10f5
--- /dev/null
+++ b/Http/MessageInterface.php
@@ -0,0 +1,50 @@
+<?php 
+
+namespace Md\Http;
+
+/**
+ * Interface MessageInterface
+ * Represents a HTTP Message
+ * 
+ */
+interface MessageInterface 
+{
+    /**
+     * Get the current message content-type
+     * @return string The message content-type
+     */
+    public function getContentType(): string;
+
+    /**
+     * Set the current message content-type
+     * @param string $_contentType The content-type to apply 
+     * @return MessageInterface
+     */
+    public function withContentType(string $_contentType): MessageInterface;
+    
+    /**
+     * Get the current message body
+     * @return string The message body
+     */
+    public function getBody(): string;
+
+    /**
+     * Set the current message body
+     * @param string $_body The message body
+     * @return MessageInterface
+     */
+    public function withBody(string $_body): MessageInterface;
+
+
+    /**
+     * Get the current message body as array
+     * @return string The message body
+     */
+    //public function getData(): array;
+    /**
+     * Set the current message body
+     * @param array $_data The message body to parse.
+     * @return MessageInterface
+     */
+    //public function withData(array $_data): MessageInterface;
+}
diff --git a/Http/Request.php b/Http/Request.php
new file mode 100644
index 0000000..96aeccb
--- /dev/null
+++ b/Http/Request.php
@@ -0,0 +1,69 @@
+<?php 
+
+namespace Md\Http;
+
+use function explode, parse_str, file_get_contents;
+
+class Request extends Message implements RequestInterface
+{
+    private UriInterface $uri;
+    //private array $route;
+    private string $method;
+    
+
+    public function __construct(?UriInterface $_uri = null)
+    {
+        parent::__construct(explode(',', $_SERVER['HTTP_ACCEPT'] ?? Message::HTML)[0] ?? Message::HTML);
+        $this->setMethod($_SERVER['REQUEST_METHOD'] ?? 'GET');
+        $this->uri = $_uri ?? new Uri($_SERVER['REQUEST_URI'] ?? '/');    
+        //$this->route = $this->uri->getParts();
+    }
+
+    public function setMethod(string $_method): RequestInterface
+    {
+        $this->method = $_method;
+        return $this;
+    }
+
+    public function getMethod(): string 
+    {
+        return $this->method;
+    }
+
+    public function getUri(): UriInterface 
+    {
+        return $this->uri;
+    }
+
+    /*public function getRoute(int $_pos): ?string
+    {
+        return $this->route[$_pos] ?? null;
+    }*/
+
+    public function getData(): array
+    {
+        switch($this->method)
+        {
+            case 'GET':
+            case 'DELETE':
+                return $this->uri->getQueryArray();
+            break;
+            case 'POST':
+                $a = Uri::secure($_POST ?? []);
+                if(!empty($_FILES)) {
+                    $a['_files'] = $_FILES;
+                }
+                return $a;
+            break;
+            case 'PATCH':
+            case 'PUT':
+                $a = [];
+                parse_str(file_get_contents('php://input'), $a);
+                return Uri::secure($a);
+            break;
+            default:
+                return [];
+            break;
+        }
+    }   
+}
diff --git a/Http/RequestInterface.php b/Http/RequestInterface.php
new file mode 100644
index 0000000..09227d0
--- /dev/null
+++ b/Http/RequestInterface.php
@@ -0,0 +1,36 @@
+<?php 
+
+namespace Md\Http; 
+
+/**
+ * Interface RequestInterface
+ * Represents the current Incoming HTTP Request (IHR)
+ * 
+ */
+interface RequestInterface extends MessageInterface
+{
+    /**
+     * Get current HTTP Message method
+     * @return string the current request method
+     */
+    public function getMethod(): string;
+
+    /**
+     * Get the Uri used by the current request
+     * @return UriInterface the Uri used by the current request
+     */
+    public function getUri(): UriInterface;
+
+    /**
+     * Get the Uri path as array
+     * @return array the Uri path as array
+     */
+    //public function getRoute(int $_pos): ?string;
+
+    /**
+     * Get current Request HTTP data (get params, post form etc...) 
+     * Data depends on the HTTP method used
+     * @return array the current request data
+     */
+    public function getData(): array;
+}
diff --git a/Http/Response.php b/Http/Response.php
new file mode 100644
index 0000000..8140153
--- /dev/null
+++ b/Http/Response.php
@@ -0,0 +1,26 @@
+<?php 
+
+namespace Md\Http;
+
+
+class Response extends Message implements ResponseInterface
+{
+    private int $code;
+
+    public function __construct()
+    {
+        parent::__construct();
+        $this->code = 200;
+    }
+
+    public function getCode(): int
+    {
+        return $this->code;
+    }
+
+    public function withCode(int $_code): ResponseInterface 
+    {
+        $this->code = $_code;
+        return $this;
+    } 
+}
diff --git a/Http/ResponseInterface.php b/Http/ResponseInterface.php
new file mode 100644
index 0000000..781c3dd
--- /dev/null
+++ b/Http/ResponseInterface.php
@@ -0,0 +1,23 @@
+<?php 
+
+namespace Md\Http;
+
+interface ResponseInterface extends MessageInterface
+{
+    //public const JSON = 'application/json; charset=utf-8';
+    //public const HTML = 'text/html';
+    
+    /**
+     * Get Response HTTP Code
+     * @return int the response http code
+     */
+    public function getCode(): int;
+
+    /**
+     * Set Response HTTP code
+     * @param int $_code the new response http code
+     * @return self 
+     */
+    public function withCode(int $_code): ResponseInterface;
+
+}
diff --git a/Http/ServerRequest.php b/Http/ServerRequest.php
new file mode 100644
index 0000000..49dc1ae
--- /dev/null
+++ b/Http/ServerRequest.php
@@ -0,0 +1,76 @@
+<?php 
+
+namespace Md\Http;
+
+use Md\App\Debug;
+
+use function explode, parse_str, file_get_contents;
+
+class ServerRequest implements ServerRequestInterface
+{
+    private static $instance = null;
+
+    public static function get(): ServerRequestInterface 
+    {
+        if(self::$instance === null) {
+            self::$instance = new static();
+        }
+
+        return self::$instance;
+    }
+
+    private string $method;
+
+    private string $contentType;
+
+    private UriInterface $uri;
+
+    private function __construct()
+    {
+        $this->method = $_SERVER['REQUEST_METHOD'] ?? 'GET';
+        $this->contentType = explode(',', $_SERVER['HTTP_ACCEPT'] ?? '*/*')[0] ?? '*/*';
+        $this->uri = new Uri($_SERVER['REQUEST_URI']);
+    }
+
+    public function getMethod(): string 
+    {
+        return $this->method;
+    }
+
+    public function getContentType(): string 
+    {
+        return $this->contentType;
+    }
+
+    public function getUri(): UriInterface 
+    {
+        return $this->uri;
+    }
+
+    public function getData(): array
+    {
+        switch($this->method)
+        {
+            case 'GET':
+            case 'DELETE':
+                return $this->uri->getQueryArray();
+            break;
+            case 'POST':
+                $a = Uri::secure($_POST ?? []);
+                if(!empty($_FILES)) {
+                    $a['_files'] = $_FILES;
+                }
+                return $a;
+            break;
+            case 'PATCH':
+            case 'PUT':
+                $a = [];
+                parse_str(file_get_contents('php://input'), $a);
+                return Uri::secure($a);
+            break;
+            default:
+                return [];
+            break;
+        }
+    }
+}
diff --git a/Http/ServerRequestInterface.php b/Http/ServerRequestInterface.php
new file mode 100644
index 0000000..17ee48a
--- /dev/null
+++ b/Http/ServerRequestInterface.php
@@ -0,0 +1,20 @@
+<?php 
+
+namespace Md\Http; 
+
+/**
+ * Interface ServerRequestInterface
+ * Represents an incoming HTTP Request (IHR)
+ * 
+ */
+interface ServerRequestInterface //extends MessageInterface
+{
+
+    public function getMethod(): string;
+
+    public function getContentType(): string;
+
+    public function getUri(): UriInterface;
+
+    public function getData(): array;
+}
\ No newline at end of file
diff --git a/Http/Uri.php b/Http/Uri.php
new file mode 100644
index 0000000..bb0923e
--- /dev/null
+++ b/Http/Uri.php
@@ -0,0 +1,121 @@
+<?php 
+
+namespace Md\Http;
+
+use function explode, parse_str, parse_url, trim;
+
+class Uri implements UriInterface 
+{
+
+    /**
+     * Secure data in array
+     * Remove paths (basename)
+     * Accept alphanumerics characters, dash, dot
+     * @return array the input array 
+     */
+    static public function secure(array $_data = []): array
+    {
+        return array_filter(array_map(function ($v) {
+            $v = basename($v);
+            if(!preg_match("/^[A-Za-z0-9\.\-]*$/", $v)) {
+                http_response_code(400);
+                exit('Bad Request');
+            }
+            return $v;
+           // return \preg_replace("/[^a-zA-Z0-9]/", "", \basename(\strip_tags($v), '.php'));
+        }, $_data));
+    }
+
+    public string $scheme;
+
+    public string $host;
+
+    public int $port;
+
+    public string $path;
+
+    public string $query;
+
+    public function __construct(string $_uri = '/')
+    {
+        $u = parse_url(filter_var($_uri, FILTER_SANITIZE_URL));
+
+        $this->withHost($u['host'] ?? $_SERVER['SERVER_NAME'] ?? 'localhost')
+             ->withPort($u['port'] ?? $_SERVER['SERVER_PORT'] ?? 0)
+             ->withPath($u['path'] ?? '')
+             ->withQuery($u['query'] ?? '');
+    }
+
+    public function __toString(): string
+    {
+        return ($this->scheme . '://' . $this->host . 
+            (!in_array($this->port, [0, 80, 443]) ? (':'. $this->port) : '') . '/' . 
+            $this->path . (!empty($this->query) ? '?'.$this->query : ''));
+    }
+
+    public function withHost(string $_host): UriInterface
+    {
+        $this->host = $_host;
+        return $this;
+    }
+
+    public function withPort(int $_port): UriInterface 
+    {
+        $this->port = (filter_var(
+            $_port, 
+            FILTER_VALIDATE_INT, 
+            ['options' => ['min_range' => 0, 'max_range' => 65535]]
+        ) !== false ? $_port : 0);
+        $this->scheme = ($this->port !== 80 ? 'https' : 'http');
+        return $this;
+    }
+
+    public function withPath(string $_path): UriInterface
+    {   
+        $this->path = mb_convert_case(preg_replace(['#\.+/#','#/+#'], '/', trim($_path ?? '', '/')), MB_CASE_LOWER);
+        return $this;
+    }
+
+    public function withQuery(string $_query): UriInterface
+    {
+        $this->query = $_query;
+        return $this;
+    }
+
+    public function withQueryArray(array $_query): UriInterface
+    {
+        return $this->withQuery(http_build_query($_query));
+    }
+
+    public function getHost(): string 
+    {
+        return $this->host;
+    }
+
+    public function getPort(): int 
+    {
+        return $this->host;
+    }
+
+    public function getPath(): string
+    {
+        return $this->path;
+    }
+
+    public function getParts(): array
+    {
+        return self::secure(explode('/', $this->path));;
+    }
+
+    public function getQuery(): string
+    {
+        return $this->query;
+    }
+
+    public function getQueryArray(): array 
+    {
+        $q = [];
+        parse_str($this->query ?? '', $q);
+        return self::secure($q);
+    }
+}
diff --git a/Http/UriInterface.php b/Http/UriInterface.php
new file mode 100644
index 0000000..0e97c2d
--- /dev/null
+++ b/Http/UriInterface.php
@@ -0,0 +1,20 @@
+<?php 
+
+namespace Md\Http;
+
+interface UriInterface 
+{
+    //public function withScheme(?string $_scheme = null): UriInterface;
+    public function withHost(string $_host): UriInterface;
+    public function withPort(int $_port): UriInterface;
+    public function withPath(string $_path): UriInterface;
+    public function withQuery(string $_query): UriInterface;
+    public function withQueryArray(array $_query): UriInterface;
+    //public function getScheme(): string;
+    public function getHost(): string; 
+    public function getPort(): int;
+    public function getPath(): string;
+    public function getParts(): array;
+    public function getQuery(): string;
+    public function getQueryArray(): array;
+}
diff --git a/Mvc/App.php b/Mvc/App.php
new file mode 100644
index 0000000..d5ff321
--- /dev/null
+++ b/Mvc/App.php
@@ -0,0 +1,108 @@
+<?php 
+
+namespace Md\Mvc;
+
+use Md\App\Debug;
+use Md\Db\Db;
+use Md\Http\Http;
+use Md\Http\Message;
+use Md\Http\Request;
+use Md\Http\RequestInterface;
+use Md\Http\Response;
+use Md\Http\ResponseInterface;
+use Md\Http\ServerRequest;
+use Md\Http\Uri;
+
+use function dirname, is_file;
+
+/**
+ * MD MVC App Launcher
+ * 
+ */
+class App  
+{
+    /**
+     * Run MVC App using Default Components
+     * @param string $_path App path (last path fragment = App namespace)
+     */
+    static public function run(array $_options): void
+    {  
+        //$s = new Uri('https://arfp.eu/crm//doc.php?id=1');
+        //$t = new Uri('https://arfp.eu:8000////crm/../doc/test///////lol/......///index.php?id=1');
+        //Debug::e([$s, $s->__toString(), $t, $t->__toString()]);
+
+       /* $web = new LocalPath($_path);
+        $root = new LocalPath(dirname($_path));
+        $app = new Module($root->getPath($_namespace));
+
+        $uri = new Uri($_SERVER['REQUEST_URI']);
+        $request = new Request($uri);*/
+
+       // $router = new Router(new Route(new Request(), $_options));
+
+        //$serverRequest = new ServerRequest();
+
+        //Debug::e([]);
+
+        $app = new App(new Route($_options), new Response());
+        
+        $app->handleRequest();
+    }
+
+    private RouterInterface $router;
+
+    public function __construct(RouterInterface $_router, ResponseInterface $_response)
+    {        
+        $this->router = $_router;
+
+        //Debug::e($this);
+
+        if(null !== ($controller = $this->router->createController())) {
+            Debug::e($this);
+        }
+        
+        Http::notFound();
+    }
+
+    public function getPath(string $_subPath = ''): string
+    {
+        return ($this->path . $_subPath);
+    }
+
+    /**
+     * Override to Load customs components
+     */
+    protected function initComponents() : void {}
+
+    /**
+     * Override to cutomize Databases components 
+     */
+    protected function initDatabases(): void
+    {
+        $conf = is_file($this->getPath('var/db.conf.php')) ? (require $this->router->getPath('var/db.conf.php')) : [];
+
+        foreach($conf as $context => $params) {
+            Db::register($context, $params);
+        }
+    }
+
+    /**
+     * Run MVC App using IRouter
+     */
+    public function handleRequest(): void 
+    {  
+        Debug::e($this);
+        $this->initDatabases();
+        $this->initComponents();
+        $response = $this->controller->handleRequest();
+
+        if($response->getContentType() === Message::HTML) {
+            $layout = new View($this->router->getPath('Views/')); 
+            $layout->setFile('_layout');
+            View::setVar('page', $response->getBody()); 
+            $response->setBody($layout->fetch());
+        }
+
+        Http::response($response);
+    }
+}
diff --git a/Mvc/AppInterface.php b/Mvc/AppInterface.php
new file mode 100644
index 0000000..57b4d48
--- /dev/null
+++ b/Mvc/AppInterface.php
@@ -0,0 +1,42 @@
+<?php 
+
+
+namespace Md\Mvc;
+
+use Md\Http\RequestInterface;
+
+interface ViewInterface 
+{
+
+}
+
+interface ControllerInterface 
+{
+
+}
+
+interface LocalPathInterface 
+{
+    public function isDir(string $_sub = ''): bool;
+    public function isFile(string $_sub): bool;
+    public function getPath(string $_sub = ''): string;
+    public function getContents(string $_sub = ''): string;
+    public function getArray(string $_sub = ''): array;
+}
+
+interface ModuleInterface extends LocalPathInterface
+{
+    public function getNamespace(string $_sub = ''): string;
+    public function getController(string $_name): string;
+    public function getViewsPath(): LocalPathInterface;
+}
+
+interface RouteInterface 
+{
+    public function getController(): ControllerInterface;
+}
+
+interface AppInterface 
+{
+    public function run(RequestInterface $request, RouteInterface $_route);
+}
diff --git a/Mvc/Controller.php b/Mvc/Controller.php
new file mode 100644
index 0000000..0ae1903
--- /dev/null
+++ b/Mvc/Controller.php
@@ -0,0 +1,96 @@
+<?php 
+
+namespace Md\Mvc;
+
+use Md\Db\RepositoryInterface;
+use Md\Db\Repository;
+use Md\Http\RequestInterface;
+use Md\Http\ResponseInterface;
+
+/**
+ * Abstract Class Controller 
+ * Default Controller implementation.
+ * Returns JSON Response
+ */
+abstract class Controller implements ControllerInterface
+{
+    /** @var RouteInterface $request The HTTP request extracted from $router */
+    protected RouteInterface $route;
+
+    /** @var ResponseInterface $response The HTTP response object */
+    protected ResponseInterface $response;
+
+    /** @var null|RepositoryInterface $repo The Repository to use or null if no repository */
+    protected ?RepositoryInterface $repo;
+
+    /** @var array $data Data sent to response */
+    protected array $data;
+
+    public function __construct()
+    {
+        $this->repo = null;
+        $this->data = [];
+        $this->onLoad();
+    }
+    
+    /**
+     * Default Controller Action
+     */
+    // abstract public function indexAction(): void;
+
+    /**
+     * Load custom components when loading the controller
+     */
+    protected function onLoad() {}
+
+    /**
+     * Load custom components before processing the request
+     */
+    protected function beforeRequest() {}
+
+    /**
+     * Execute actions after processing the request
+     */
+    protected function afterRequest() {}
+
+    public function getResponse(): ResponseInterface
+    {
+        return $this->response;
+    }
+
+    /**
+     * Handle current request
+     */
+    public function handleRequest(RouteInterface $_route, ResponseInterface $_response): ResponseInterface
+    {
+        $this->route = $_route;
+        $this->response = $_response;
+
+        $a = ($this->route->getAction());
+
+        if(!method_exists($this, $a)) {
+            return $this->response->withCode(404)->withBody('Invalid Action');
+        }
+
+        $this->beforeRequest();
+        $this->{$a}();
+        $this->afterRequest();
+
+        if($this->response->getContentType() === ResponseInterface::JSON) {
+            return $this->response->setBody(json_encode($this->data, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES));
+        }
+
+        $view = new View($this->request->getLocalPath('Views/')); 
+        return $this->response->setBody($view->setFile($this->request->getView())->fetch($this->data));
+    }
+
+    /**
+     * Set Generic Repository from table name and primary key name 
+     * A generic repo use Db::getContext('default')
+     */
+    public function setRepository(string $_table, string $_pk)
+    {
+        $this->repo = new Repository($_table, $_pk);
+    }
+
+}
diff --git a/Mvc/ControllerInterface.php b/Mvc/ControllerInterface.php
new file mode 100644
index 0000000..4914acb
--- /dev/null
+++ b/Mvc/ControllerInterface.php
@@ -0,0 +1,17 @@
+<?php 
+
+namespace Md\Mvc;
+
+use Md\Http\RequestInterface;
+use Md\Http\ResponseInterface;
+
+interface ControllerInterface 
+{
+    /**
+     * Handle current request and returns response object
+     * @param RouteInterface $_route the request to handle
+     * @return ResponseInterface 
+     */
+    public function handleRequest(RouteInterface $_route, ResponseInterface $_response): ResponseInterface;
+
+}
\ No newline at end of file
diff --git a/Mvc/ControllerView.php b/Mvc/ControllerView.php
new file mode 100644
index 0000000..980419d
--- /dev/null
+++ b/Mvc/ControllerView.php
@@ -0,0 +1,79 @@
+<?php 
+
+namespace Md\Mvc;
+
+use Md\Db\IRepository;
+use Md\Db\Repository;
+use Md\Http\IRequest;
+use Md\Http\IResponse;
+use Md\Http\IRouter;
+use Md\Http\Response;
+use Md\Views\View;
+
+/**
+ * Abstract Class ControllerView
+ */
+abstract class ControllerView extends Controller implements IController
+{
+    /** @var IRouter $router The router used by current App */
+    protected IRouter $router; 
+
+    /** @var IRequest $request The HTTP request extracted from $router */
+    protected IRequest $request;
+
+    /** @var IResponse $response The HTTP response object */
+    protected IResponse $response;
+
+    /** @var null|IRepository $repo The Repository to use or null if no repository */
+    protected ?IRepository $repo;
+
+    /** @var bool $view defines if a view should be loaded (true) */
+    protected bool $view;
+
+    public function __construct(IRouter $_router)
+    {
+        $this->router = $_router;
+        $this->request = $_router->getRequest();
+        $this->response = new Response();
+        $this->repo = null;
+        $this->view = false;
+        $this->init();
+    }
+
+    protected function init() 
+    {
+        
+    }
+
+    public function handleRequest(): IResponse
+    {
+        $a = $this->request->getAction();
+
+        if(!method_exists($this, $a)) {
+            return $this->response->setCode(404)->addData('error', 'Invalid Action');
+        }
+
+        $this->{$a}();
+
+        if($this->view === false) {
+            return $this->response;
+        }
+
+        $layout = new View($this->router->getViewsPath()); 
+        $layout->setFile('_layout');
+        $layout->setChild('page', $this->request->getView());  
+        $this->response->setView($layout);    
+        return $this->response;
+    }
+
+    /**
+     * Set Generic Repository from table name and primary key name 
+     * Remember to open the connection with DbContext before use any repo
+     */
+    public function setRepository(string $_table, string $_pk)
+    {
+        $this->repo = new Repository($_table, $_pk);
+    }
+
+    abstract public function indexAction(): void;
+}
\ No newline at end of file
diff --git a/Mvc/Route.php b/Mvc/Route.php
new file mode 100644
index 0000000..0aa8480
--- /dev/null
+++ b/Mvc/Route.php
@@ -0,0 +1,111 @@
+<?php 
+
+namespace Md\Mvc;
+
+use Md\App\Debug;
+use Md\Http\Http;
+use Md\Http\ServerRequest;
+use Md\Http\ServerRequestInterface;
+
+use function mb_convert_case, trim;
+
+class Route implements RouteInterface, RouterInterface
+{
+    private string $path;
+
+    private string $realPath;
+
+    private string $namespace;
+
+    private string $instance;
+
+    private string $app;
+
+    private string $module;
+
+    private string $web;
+
+    private array $route;
+
+    private ServerRequestInterface $request;
+
+
+    public function __construct(array $_options)
+    {
+        $this->path = (dirname($_options['path']) . DIRECTORY_SEPARATOR);
+        $this->realPath = $this->path;
+        $this->namespace = '\\'.$_options['namespace'];
+        $this->instance = basename($_options['path']);
+        $this->request = ServerRequest::get();
+        $this->route = $this->request->getUri()->getParts();
+
+        $this->route[0] = mb_convert_case($this->route[0] ?? 'Home', MB_CASE_TITLE);
+
+        if($this->route[0] === 'Api') {
+            $this->namespace .= '\\Api';
+            $this->realPath .= 'Api' . DIRECTORY_SEPARATOR;
+        } 
+        elseif(is_dir($this->path . 'App' . DIRECTORY_SEPARATOR . $this->route[0])) {
+            $this->namespace .= '\\App\\'.$this->route[0];
+            $this->realPath .= 'App' . DIRECTORY_SEPARATOR . $this->route[0] . DIRECTORY_SEPARATOR;
+        }
+
+        if($this->path !== $this->realPath) {
+            array_shift($this->route);
+            $this->route[0] = mb_convert_case($this->route[0] ?? 'Home', MB_CASE_TITLE);
+        }
+
+        $this->route[1] = $this->route[1] ?? 'index';
+        $this->route[2] = $this->route[2] ?? null;
+    }
+
+    public function getPath(string $_sub = ''): string 
+    {
+        return ($this->path . $_sub);
+    }
+
+    public function getRealPath(string $_sub = ''): string 
+    {
+        return ($this->realPath . $_sub);
+    }
+
+    public function getWebPath(string $_sub = ''): string
+    {
+        return ($this->path . $this->instance . DIRECTORY_SEPARATOR . $_sub);
+    }
+
+    public function getRequest(): ServerRequestInterface
+    {
+        return $this->request;
+    }
+
+    public function getController(): string
+    {
+        return ($this->route[0] . 'Controller');
+    }
+
+    public function getAction(): string
+    {
+        return ($this->route[1] . 'Action');
+    }
+
+    public function getId(): ?string
+    {
+        return $this->route[2];
+    }
+
+    public function getRoute(): RouteInterface
+    {
+        return $this;
+    }
+
+    public function createController(): ?ControllerInterface
+    {
+        if(is_file($this->getRealPath('Controllers' . DIRECTORY_SEPARATOR . $this->getController() .'.php'))) {
+            $c = ($this->namespace . 'Controllers\\' . $this->getController());
+            return new $c();
+        }
+
+        return null;
+    }
+}
diff --git a/Mvc/RouteInterface.php b/Mvc/RouteInterface.php
new file mode 100644
index 0000000..2c55edf
--- /dev/null
+++ b/Mvc/RouteInterface.php
@@ -0,0 +1,22 @@
+<?php 
+
+namespace Md\Mvc;
+
+use Md\Http\ServerRequestInterface;
+
+interface RouteInterface
+{
+    public function getPath(string $_sub = ''): string;
+
+    public function getRealPath(string $_sub = ''): string;
+
+    public function getWebPath(string $_sub = ''): string;
+
+    public function getRequest(): ServerRequestInterface;
+
+    public function getController(): string;
+
+    public function getAction(): string;
+
+    public function getId(): ?string;
+}
diff --git a/Mvc/RouterInterface.php b/Mvc/RouterInterface.php
new file mode 100644
index 0000000..91a4aa5
--- /dev/null
+++ b/Mvc/RouterInterface.php
@@ -0,0 +1,18 @@
+<?php 
+
+namespace Md\Mvc;
+
+use Md\Http\RequestInterface;
+
+/**
+ * Interface RouterInterface
+ * 
+ * Locate the controller using RouteInterface Object
+ * 
+ */
+interface RouterInterface
+{
+    public function getRoute(): RouteInterface;
+
+    public function createController(): ?ControllerInterface;
+}
diff --git a/Mvc/View.php b/Mvc/View.php
new file mode 100644
index 0000000..8f80338
--- /dev/null
+++ b/Mvc/View.php
@@ -0,0 +1,63 @@
+<?php
+
+namespace Md\Mvc;
+
+use Md\Http\Http;
+
+class View implements ViewInterface
+{
+    static protected array $vars = [];
+
+    public static function getVar(string $_name, $_default = null)
+    {
+        return self::$vars[$_name] ?? $_default;
+    }
+
+    public static function setVar(string $_name, $_value)
+    {
+        self::$vars[$_name] = $_value;
+    }
+
+    protected string $path;
+
+    protected string $file;
+
+    protected array $childs;
+
+    public function __construct(string $_path)
+    {
+        $this->path = $_path;
+        $this->file = 'index';
+        $this->childs = [];
+    }
+
+    public function setFile(string $_filename): ViewInterface
+    {
+        $this->file = ($this->path.$_filename.'.php');
+        
+        if(!\is_file($this->file)) {
+            Http::notFound('invalid view ('.$_filename.')');
+        }
+
+        return $this;
+    }
+
+    public function fetch(array $_vars = []) : string
+    {
+        foreach($this->childs as $k => $v) {
+            $_vars[$k] = $v->fetch($_vars);
+        }
+
+        \ob_start();
+        \extract($_vars);
+        \extract(self::$vars, EXTR_SKIP);
+        require ($this->file);
+        return \ob_get_clean();
+    }
+
+    public function setChild(string $_key, string $_filename): ViewInterface
+    {
+        $this->childs[$_key] = (new self($this->path))->setFile($_filename);
+        return $this->childs[$_key];
+    }
+}
diff --git a/Mvc/ViewInterface.php b/Mvc/ViewInterface.php
new file mode 100644
index 0000000..7bdaf4b
--- /dev/null
+++ b/Mvc/ViewInterface.php
@@ -0,0 +1,12 @@
+<?php 
+
+namespace Md\Mvc;
+
+interface ViewInterface 
+{
+    public function setFile(string $_filename): ViewInterface;
+
+    public function fetch(array $_data): string;
+
+    public function setChild(string $key, string $_filename): ViewInterface;
+}
\ No newline at end of file
diff --git a/README.md b/README.md
index 01684ef..a58139e 100644
--- a/README.md
+++ b/README.md
@@ -1 +1,8 @@
-# MD_PHP_MVC
\ No newline at end of file
+# PHP MVC BASIC EXAMPLE
+
+For educational purposes. Please do not use this on production environment.
+
+
+## Usage
+
+https://github.com/mdevoldere/edu-php-mvc-skeleton
\ No newline at end of file
diff --git a/composer.json b/composer.json
new file mode 100644
index 0000000..7251aa5
--- /dev/null
+++ b/composer.json
@@ -0,0 +1,36 @@
+{
+    "name": "mdevoldere/edu-php-mvc",
+    "description": "A simple MVC for educationnal purposes",
+    "type": "library",
+    "version": "0.0.1",
+    "minimum-stability": "dev",
+    "license": "GPL-3.0-or-later",
+    "authors": [
+        {
+            "name": "MDevoldere",
+            "email": "dev@devoldere.net",
+            "homepage": "https://devoldere.net",
+            "role": "Owner"
+        }
+    ],
+    "repositories": [
+        {
+            "type": "vcs",
+            "url": "https://github.com/mdevoldere/edu-php-db.git"
+        },
+        {
+            "type": "vcs",
+            "url": "https://github.com/mdevoldere/edu-php-mvc.git"
+        }
+    ],
+    "require": {
+        "php" : ">=7.4",
+        "ext-mbstring": "*",
+        "mdevoldere/edu-php-db": "dev-mdev"
+    },
+    "autoload": {
+        "psr-4": {
+            "Md\\": ""
+        }
+      }
+}