diff --git a/.vscode/launch.json b/.vscode/launch.json
index b57adec8..fa238403 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -8,7 +8,8 @@
             "type": "lldb",
             "request": "launch",
             "name": "clice_socket",
-            "program": "${workspaceFolder}/build/bin/clice"
+            "program": "${workspaceFolder}/build/bin/clice",
+            "args": ["--config=/home/ykiko/C++/clice2/docs/clice.toml"]
         },
         {
             "type": "lldb",
@@ -34,7 +35,7 @@
             "program": "${workspaceFolder}/build/bin/clice-tests",
             "args": [
                 "--test-dir=/home/ykiko/C++/clice2/tests",
-                "--gtest_filter=clice.TemplateResolver"
+                "--gtest_filter=TemplateResolver.DefaultArgument"
             ],
             "cwd": "${workspaceFolder}"
         },
diff --git a/docs/clice.toml b/docs/clice.toml
index 57657ba3..360b9cfc 100644
--- a/docs/clice.toml
+++ b/docs/clice.toml
@@ -1,6 +1,6 @@
 [server]
 # "pipe" or "socket"
-mode = "pipe"
+mode = "socket"
 port = 50051
 address = "127.0.0.1"
 
diff --git a/include/Basic/URI.h b/include/Basic/URI.h
new file mode 100644
index 00000000..2a030a58
--- /dev/null
+++ b/include/Basic/URI.h
@@ -0,0 +1,5 @@
+namespace clice {
+
+
+    
+}
\ No newline at end of file
diff --git a/include/Compiler/Clang.h b/include/Compiler/Clang.h
index 5a964e5c..61153468 100644
--- a/include/Compiler/Clang.h
+++ b/include/Compiler/Clang.h
@@ -42,6 +42,8 @@ clang::SourceLocation get(clang::SourceRange range) {
 #define VISIT_TYPE(type) bool Visit##type(const clang::type* type)
 #define VISIT_TYPELOC(type) bool Visit##type(clang::type loc)
 
+#define TRAVERSE_DECL(type) bool Traverse##type(clang::type* decl)
+
 using lookup_result = clang::DeclContext::lookup_result;
 
 }  // namespace clang
diff --git a/include/Compiler/Semantic.h b/include/Compiler/Semantic.h
new file mode 100644
index 00000000..a4138bfc
--- /dev/null
+++ b/include/Compiler/Semantic.h
@@ -0,0 +1,513 @@
+#include "Compiler.h"
+#include "Resolver.h"
+
+#include "Support/Enum.h"
+#include "Support/FileSystem.h"
+#include "Utility.h"
+
+namespace clice {
+
+enum class RelationKinds : uint32_t {
+    Invalid,
+    Declaration,
+    Definition,
+    Reference,
+    // Write Relation.
+    Read,
+    Write,
+    Interface,
+    Implementation,
+    /// When target is a type definition of source, source is possible type or constructor.
+    TypeDefinition,
+
+    /// When target is a base class of source.
+    Base,
+    /// When target is a derived class of source.
+    Derived,
+
+    /// When target is a constructor of source.
+    Constructor,
+    /// When target is a destructor of source.
+    Destructor,
+
+    // When target is a caller of source.
+    Caller,
+    // When target is a callee of source.
+    Callee,
+};
+
+struct RelationKind : enum_type<RelationKinds, true> {
+    using enum RelationKinds;
+    using enum_type::enum_type;
+    using enum_type::operator=;
+};
+
+enum class OccurrenceKind {
+    /// This occurrence directly corresponds to a unique source symbol.
+    Source,
+    /// This occurrence is a macro expansion.
+    MacroExpansion,
+    /// This occurrence is from `PseudoInstantiation` and may be not correct.
+    PseudoInstantiation,
+    /// This occurrence is from `ImplicitInstantiation` or `ExplicitInstantiation` of a template.
+    Instantiation,
+};
+
+class SemanticVisitor : public clang::RecursiveASTVisitor<SemanticVisitor> {
+public:
+    using Base = clang::RecursiveASTVisitor<SemanticVisitor>;
+
+    SemanticVisitor(Compiler& compiler) :
+        sema(compiler.sema()), resolver(compiler.resolver()), srcMgr(compiler.srcMgr()) {}
+
+public:
+    /// ============================================================================
+    ///                                Declaration
+    /// ============================================================================
+
+    TRAVERSE_DECL(Decl) {
+        decls.push_back(decl);
+        auto result = Base::TraverseDecl(decl);
+        decls.pop_back();
+        return result;
+    }
+
+    VISIT_DECL(NamespaceDecl) {
+        /// `namespace Foo { }`
+        ///             ^~~~ definition
+        handleOccurrence(decl, decl->getLocation());
+        return true;
+    }
+
+    VISIT_DECL(NamespaceAliasDecl) {
+        /// `namespace Foo = Bar`
+        ///             ^     ^~~~ reference
+        ///             ^~~~ definition
+        handleOccurrence(decl, decl->getLocation());
+        handleOccurrence(decl->getNamespace(), decl->getTargetNameLoc());
+        return true;
+    }
+
+    VISIT_DECL(UsingDirectiveDecl) {
+        /// `using namespace Foo`
+        ///                   ^~~~~~~ reference
+        handleOccurrence(decl->getNominatedNamespace(), decl->getLocation());
+        return true;
+    }
+
+    VISIT_DECL(LabelDecl) {
+        /// `label:`
+        ///    ^~~~ definition
+        handleOccurrence(decl, decl->getLocation());
+        return true;
+    }
+
+    VISIT_DECL(FieldDecl) {
+        /// `int foo;`
+        ///       ^~~~ definition
+        handleOccurrence(decl, decl->getLocation());
+        return true;
+    }
+
+    VISIT_DECL(EnumConstantDecl) {
+        /// `enum Foo { bar };`
+        ///              ^~~~ definition
+        handleOccurrence(decl, decl->getLocation());
+        return true;
+    }
+
+    VISIT_DECL(UsingDecl) {
+        /// `using Foo::bar;`
+        ///              ^~~~ reference
+        handleOccurrence(decl, decl->getLocation());
+        /// FIXME:
+        return true;
+    }
+
+    VISIT_DECL(BindingDecl) {
+        /// `auto [a, b] = std::make_tuple(1, 2);`
+        ///        ^~~~ definition
+        handleOccurrence(decl, decl->getLocation());
+        return true;
+    }
+
+    VISIT_DECL(TemplateTypeParmDecl) {
+        /// `template <typename T>`
+        ///                     ^~~~ definition
+        handleOccurrence(decl, decl->getLocation());
+        return true;
+    }
+
+    VISIT_DECL(TemplateTemplateParmDecl) {
+        /// `template <template <typename> class T>`
+        ///                                      ^~~~ definition
+        handleOccurrence(decl, decl->getLocation());
+        return true;
+    }
+
+    VISIT_DECL(NonTypeTemplateParmDecl) {
+        /// `template <int N>`
+        ///                ^~~~ definition
+        handleOccurrence(decl, decl->getLocation());
+        return true;
+    }
+
+    VISIT_DECL(TagDecl) {
+        /// `Base::TraverseClassTemplate...Decl` will also traverse it's templated class.
+        /// We already handled the template class in `VisitClassTemplate...Decl`. So we skip
+        /// them here.
+        if(decl->getDescribedTemplate() ||
+           llvm::isa<clang::ClassTemplateSpecializationDecl,
+                     clang::ClassTemplatePartialSpecializationDecl>(decl)) {
+            return true;
+        }
+
+        /// `struct/class/union/enum Foo { };`
+        ///                           ^~~~ declaration/definition
+        handleOccurrence(decl, decl->getLocation());
+        return true;
+    }
+
+    VISIT_DECL(ClassTemplateDecl) {
+        /// `template <typename T> class Foo { };`
+        ///                               ^~~~ declaration/definition
+        handleOccurrence(decl, decl->getLocation());
+        return true;
+    }
+
+    VISIT_DECL(ClassTemplatePartialSpecializationDecl) {
+        /// It's possible that a class template specialization is a full specialization or a
+        /// explicit instantiation. And `ClassTemplatePartialSpecializationDecl` is the subclass of
+        /// `ClassTemplateSpecializationDecl`, it is also handled here.
+        ///
+        /// For full specialization:
+        /// `template <> class Foo<int> { };`
+        ///                     ^~~~ declaration/definition
+        ///
+        /// For explicit instantiation:
+        /// `template class Foo<int>;`
+        ///                  ^~~~ reference
+        handleOccurrence(decl, decl->getLocation());
+        return true;
+    }
+
+    VISIT_DECL(FunctionDecl) {
+        /// Because `TraverseFunctionTemplateDecl` will also traverse it's templated function. We
+        /// already handled the template function in `VisitFunctionTemplateDecl`. So we skip them
+        /// here.
+        if(decl->getDescribedFunctionTemplate()) {
+            return true;
+        }
+
+        /// `void foo();`
+        ///         ^~~~ declaration/definition
+        handleOccurrence(decl, decl->getLocation());
+        return true;
+    }
+
+    VISIT_DECL(FunctionTemplateDecl) {
+        /// `template <typename T> void foo();`
+        ///                               ^~~~ declaration/definition
+        handleOccurrence(decl, decl->getLocation());
+
+        /// `template void foo<int>();`
+        ///                  ^~~~ reference
+
+        /// FIXME: Clang currently doesn't record the information of explicit instantiation
+        /// correctly. See https://github.com/llvm/llvm-project/issues/115418. And it is not added
+        /// to its lexical context. So here we use a workaround to handle explicit instantiation of
+        /// function template.
+
+        // for(auto spec: decl->specializations()) {
+        //     auto kind = spec->getTemplateSpecializationKind();
+        //     if(kind == clang::TSK_ExplicitInstantiationDeclaration ||
+        //        kind == clang::TSK_ExplicitInstantiationDefinition) {
+        //         /// WORKAROUND: Clang currently doesn't record the location of explicit
+        //         /// instantiation. Use the location of the point of instantiation instead.
+        //         if(auto location = builder.addLocation(spec->getPointOfInstantiation())) {
+        //             auto symbol = builder.addSymbol(decl);
+        //             symbol.addOccurrence(location);
+        //             symbol.addReference(location);
+        //         }
+        //     }
+        // }
+
+        return true;
+    }
+
+    VISIT_DECL(TypedefNameDecl) {
+        /// Skip the typedef name declaration that is a type alias template.
+        if(decl->getDescribedTemplate()) {
+            return true;
+        }
+
+        /// `using Foo = int;`
+        ///             ^~~~ declaration/definition
+        handleOccurrence(decl, decl->getLocation());
+        return true;
+    }
+
+    VISIT_DECL(TypeAliasTemplateDecl) {
+        /// FIXME: the location of type alias template is not recorded correctly, actually
+        /// it is the location of using keyword. But location its templated type is correct.
+        /// Temporarily use the location of the templated type.
+
+        /// `template <typename T> using Foo = T;`
+        ///                               ^~~~ definition
+        handleOccurrence(decl, decl->getLocation());
+        return true;
+    }
+
+    VISIT_DECL(VarDecl) {
+        /// Because `TraverseVarTemplateSpecializationDecl` will also traverse it's templated
+        /// variable. We already handled the template variable in `VisitVar...`.
+        /// So we skip them here.
+        if(decl->getDescribedVarTemplate() ||
+           llvm::isa<clang::VarTemplateSpecializationDecl,
+                     clang::VarTemplatePartialSpecializationDecl>(decl)) {
+            return true;
+        }
+
+        /// `int foo;`
+        ///       ^~~~ declaration/definition
+        handleOccurrence(decl, decl->getLocation());
+        return true;
+    }
+
+    VISIT_DECL(VarTemplateDecl) {
+        /// `template <typename T> int foo;`
+        ///                             ^~~~ declaration/definition
+        handleOccurrence(decl, decl->getLocation());
+        return true;
+    }
+
+    VISIT_DECL(VarTemplateSpecializationDecl) {
+        /// FIXME: it's strange that `VarTemplateSpecializationDecl` occurs in the lexical context.
+        /// This should be a bug of clang. Skip it here. And clang also doesn't record the
+        /// information about explicit instantiation of var template correctly. Skip them
+        /// temporarily.
+        auto kind = decl->getSpecializationKind();
+        if(kind == clang::TSK_ImplicitInstantiation ||
+           kind == clang::TSK_ExplicitInstantiationDeclaration ||
+           kind == clang::TSK_ExplicitInstantiationDefinition) {
+            return true;
+        }
+
+        /// It's possible that a var template specialization is a full specialization or a explicit
+        /// instantiation. And `VarTemplatePartialSpecializationDecl` is the subclass of
+        /// `VarTemplateSpecializationDecl`, it is also handled here.
+        ///
+        /// For full specialization:
+        /// `template <> int foo<int>;`
+        ///                    ^~~~ declaration/definition
+        ///
+        /// For explicit instantiation:
+        /// `template int foo<int>;`
+        ///                ^~~~ reference
+        handleOccurrence(decl, decl->getLocation());
+        return true;
+    }
+
+    VISIT_DECL(ConceptDecl) {
+        /// `template <typename T> concept Foo = ...;`
+        ///                                 ^~~~ definition
+        handleOccurrence(decl, decl->getLocation());
+        return true;
+    }
+
+    bool TraverseConceptReference(clang::ConceptReference* reference) {
+        /// `requires Foo<T>;`
+        ///            ^~~~ reference
+        handleOccurrence(reference->getNamedConcept(), reference->getConceptNameLoc());
+
+        return Base::TraverseConceptReference(reference);
+    }
+
+    /// ============================================================================
+    ///                                  TypeLoc
+    /// ============================================================================
+
+    /// We don't care about type without location information.
+    constexpr bool TraverseType [[gnu::const]] (clang::QualType) {
+        return true;
+    }
+
+    VISIT_TYPELOC(TagTypeLoc) {
+        /// `struct Foo { }; Foo foo`
+        ///                   ^~~~ reference
+        handleOccurrence(loc.getDecl(), loc.getNameLoc());
+        return true;
+    }
+
+    VISIT_TYPELOC(TypedefTypeLoc) {
+        /// `using Foo = int; Foo foo`
+        ///                    ^~~~ reference
+        handleOccurrence(loc.getTypedefNameDecl(), loc.getNameLoc());
+        return true;
+    }
+
+    VISIT_TYPELOC(TemplateTypeParmTypeLoc) {
+        /// `template <typename T> void foo(T t)`
+        ///                                 ^~~~ reference
+        handleOccurrence(loc.getDecl(), loc.getNameLoc());
+        return true;
+    }
+
+    VISIT_TYPELOC(TemplateSpecializationTypeLoc) {
+        /// `std::vector<int>`
+        ///        ^~~~ reference
+        handleOccurrence(declForType(loc.getType()), loc.getTemplateNameLoc());
+        return true;
+    }
+
+    VISIT_TYPELOC(DependentNameTypeLoc) {
+        /// `std::vector<T>::value_type`
+        ///                      ^~~~ reference
+        for(auto decl: resolver.lookup(loc.getTypePtr())) {
+            handleOccurrence(decl, loc.getNameLoc());
+        }
+        return true;
+    }
+
+    VISIT_TYPELOC(DependentTemplateSpecializationTypeLoc) {
+        /// `std::allocator<T>::rebind<U>`
+        ///                       ^~~~ reference
+        for(auto decl: resolver.lookup(loc.getTypePtr())) {
+            handleOccurrence(decl, loc.getTemplateNameLoc());
+        }
+        return true;
+    }
+
+    /// ============================================================================
+    ///                                Specifier
+    /// ============================================================================
+
+    bool TraverseCXXBaseSpecifier(const clang::CXXBaseSpecifier& base) {
+        return Base::TraverseCXXBaseSpecifier(base);
+    }
+
+    /// We don't care about name specifier without location information.
+    constexpr bool TraverseNestedNameSpecifier [[gnu::const]] (clang::NestedNameSpecifier*) {
+        return true;
+    }
+
+    bool TraverseNestedNameSpecifierLoc(clang::NestedNameSpecifierLoc loc) {
+        if(!loc) {
+            return true;
+        }
+
+        auto NNS = loc.getNestedNameSpecifier();
+        switch(NNS->getKind()) {
+            case clang::NestedNameSpecifier::Namespace: {
+                handleOccurrence(NNS->getAsNamespace(), loc.getLocalBeginLoc());
+                break;
+            }
+            case clang::NestedNameSpecifier::NamespaceAlias: {
+                handleOccurrence(NNS->getAsNamespaceAlias(), loc.getLocalBeginLoc());
+                break;
+            }
+            case clang::NestedNameSpecifier::Identifier: {
+                assert(NNS->isDependent() && "Identifier NNS should be dependent");
+                // FIXME: use TemplateResolver here.
+                break;
+            }
+            case clang::NestedNameSpecifier::TypeSpec:
+            case clang::NestedNameSpecifier::TypeSpecWithTemplate:
+            case clang::NestedNameSpecifier::Global:
+            case clang::NestedNameSpecifier::Super: {
+                break;
+            };
+        }
+
+        return Base::TraverseNestedNameSpecifierLoc(loc);
+    }
+
+    bool TraverseConstructorInitializer(clang::CXXCtorInitializer* init) {
+        return Base::TraverseConstructorInitializer(init);
+    }
+
+    /// ============================================================================
+    ///                                 Statement
+    /// ============================================================================
+
+    VISIT_EXPR(DeclRefExpr) {
+        /// `foo = 1`
+        ///   ^~~~ reference
+        handleOccurrence(expr->getDecl(), expr->getLocation());
+        return true;
+    }
+
+    VISIT_EXPR(MemberExpr) {
+        /// `foo.bar`
+        ///       ^~~~ reference
+        handleOccurrence(expr->getMemberDecl(), expr->getMemberLoc());
+        return true;
+    }
+
+    VISIT_EXPR(DependentScopeDeclRefExpr) {
+        /// `std::is_same<T, U>::value`
+        ///                        ^~~~ reference
+        for(auto decl: resolver.lookup(expr)) {
+            handleOccurrence(decl, expr->getNameInfo().getLoc());
+        }
+        return true;
+    }
+
+    VISIT_EXPR(CXXDependentScopeMemberExpr) {
+        /// `std::is_same<T, U>::value.T::value`
+        ///                                 ^~~~ reference
+
+        return true;
+    }
+
+    VISIT_EXPR(CallExpr) {
+        // TODO: consider lambda expression.
+        return true;
+    }
+
+public:
+    consteval bool VisitImplicitInstantiation() {
+        return true;
+    }
+
+    /// An occurrence directly corresponding to a symbol in source code.
+    /// In most cases, a location just correspondings to unique decl.
+    /// So a location will be just visited once. But in some other cases,
+    /// a location may correspond to multiple decls. Note that we already
+    /// filter some nodes with invalid location.
+    ///
+    /// Always uses spelling location if the original location is a macro location.
+    void handleOccurrence(const clang::Decl* decl,
+                          clang::SourceLocation location,
+                          OccurrenceKind kind = OccurrenceKind::Source) {
+        if(location.isMacroID()) {
+            if(srcMgr.isMacroArgExpansion(location)) {
+                auto spelling = srcMgr.getSpellingLoc(location);
+                dump(spelling);
+                auto expansion = srcMgr.getExpansionLoc(location);
+                dump(expansion);
+                llvm::outs() << "-----------------------------------------------------\n";
+            }
+        }
+    }
+
+    void dump(clang::SourceLocation loc) {
+        auto location = srcMgr.getPresumedLoc(loc);
+        llvm::SmallString<128> path;
+        auto err = fs::real_path(location.getFilename(), path);
+        llvm::outs() << path << ":" << location.getLine() << ":" << location.getColumn() << "\n";
+    }
+
+    /// Always uses expansion location if the original location is a macro location.
+    void handleRelation(const clang::Decl* decl, RelationKind kind, clang::SourceRange range) {
+        ///
+    }
+
+private:
+    clang::Sema& sema;
+    TemplateResolver& resolver;
+    clang::SourceManager& srcMgr;
+    llvm::SmallVector<clang::Decl*> decls;
+};
+
+}  // namespace clice
diff --git a/include/Server/Config.h b/include/Server/Config.h
index cbf42c2e..9fb12251 100644
--- a/include/Server/Config.h
+++ b/include/Server/Config.h
@@ -3,17 +3,19 @@
 #include <string>
 #include <vector>
 
+#include "llvm/ADT/StringRef.h"
+
 namespace clice::config {
 
 /// read the config file, call when the program starts.
-int parse(int argc, const char** argv);
+int parse(llvm::StringRef execute, llvm::StringRef filepath);
 
 /// initialize the config, replace all predefined variables in the config file.
 /// called in `Server::initialize`.
 void init(std::string_view workplace);
 
 struct ServerOption {
-    std::string mode = "pipe";
+    std::string mode = "socket";
     unsigned int port;
     std::string address;
 };
diff --git a/include/Server/Server.h b/include/Server/Server.h
index 7487f7eb..1f7aa993 100644
--- a/include/Server/Server.h
+++ b/include/Server/Server.h
@@ -1,6 +1,9 @@
 #pragma once
 
+#include "Server/Config.h"
 #include "Basic/Basic.h"
+#include "Support/JSON.h"
+#include "llvm/ADT/FunctionExtras.h"
 
 namespace clice::proto {
 
@@ -70,6 +73,38 @@ struct InitializedParams {};
 
 namespace clice {
 
-int run(int argc, const char** argv);
+class Server {
+public:
+    Server(const config::ServerOption& option);
 
-}
+    void run(llvm::unique_function<void()> callback);
+
+    void write(llvm::StringRef message);
+
+    void request();
+
+    void response(json::Value id, json::Value result);
+
+    void notify();
+
+    void error();
+
+    bool hasMessage() {
+        return !messages.empty();
+    }
+
+    json::Value& peek() {
+        return messages.front();
+    }
+
+    void consume() {
+        messages.erase(messages.begin());
+    }
+
+public:
+    void* writer;
+    llvm::SmallVector<json::Value> messages;
+    llvm::unique_function<void()> callback;
+};
+
+}  // namespace clice
diff --git a/include/Support/Format.h b/include/Support/Format.h
new file mode 100644
index 00000000..a410c629
--- /dev/null
+++ b/include/Support/Format.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include <format>
+
+#include "llvm/ADT/StringRef.h"
+
+template <>
+struct std::formatter<llvm::StringRef> : std::formatter<std::string_view> {
+    template <typename ParseContext>
+    constexpr auto parse(ParseContext& ctx) {
+        return std::formatter<std::string_view>::parse(ctx);
+    }
+
+    template <typename FormatContext>
+    auto format(llvm::StringRef s, FormatContext& ctx) const {
+        return std::formatter<std::string_view>::format(std::string_view(s.str()), ctx);
+    }
+};
diff --git a/scripts/build-dev-test.sh b/scripts/build-dev-test.sh
index 2c219785..853a3147 100755
--- a/scripts/build-dev-test.sh
+++ b/scripts/build-dev-test.sh
@@ -1 +1 @@
-cmake -B build -G Ninja -DCMAKE_CXX_COMPILER=clang++ -DCMAKE_C_COMPILER=clang -DCMAKE_BUILD_TYPE=Debug -DCLICE_ENABLE_TEST=ON -DCMAKE_CXX_FLAGS="-fno-rtti -g -O0"
\ No newline at end of file
+cmake -B build -G Ninja -DCMAKE_CXX_COMPILER=clang++ -DCMAKE_C_COMPILER=clang -DCMAKE_BUILD_TYPE=Debug -DCLICE_ENABLE_TEST=ON -DCMAKE_CXX_FLAGS="-DSPDLOG_NO_EXCEPTIONS -fno-rtti -fno-exceptions -g -O0"
\ No newline at end of file
diff --git a/src/Basic/URI.cpp b/src/Basic/URI.cpp
new file mode 100644
index 00000000..9cf87203
--- /dev/null
+++ b/src/Basic/URI.cpp
@@ -0,0 +1 @@
+#include "Basic/URI.h"
\ No newline at end of file
diff --git a/src/Server/Config.cpp b/src/Server/Config.cpp
index 11408f97..2b3aad8b 100644
--- a/src/Server/Config.cpp
+++ b/src/Server/Config.cpp
@@ -1,3 +1,4 @@
+
 #include <toml++/toml.hpp>
 
 #include <Server/Config.h>
@@ -6,6 +7,9 @@
 #include <Support/FileSystem.h>
 #include <llvm/ADT/StringMap.h>
 
+#include "Support/Format.h"
+#include "Support/JSON.h"
+
 namespace clice::config {
 
 namespace {
@@ -61,23 +65,31 @@ std::string replace(std::string_view text) {
 
 }  // namespace
 
-int parse(int argc, const char** argv) {
-    predefined["binary"] = path::parent_path(argv[0]);
+int parse(llvm::StringRef execute, llvm::StringRef filepath) {
+    auto toml = toml::parse_file(filepath);
+    if(toml.failed()) {
+        llvm::errs() << std::format("Failed to parse config file: {}, Beacuse {}\n",
+                                    filepath,
+                                    toml.error().description());
+        return -1;
+    }
 
-    // FIXME:
-    // if(version) {
-    //     llvm::outs() << "clice version: " << predefined.version << '\n';
-    //     return 0;
-    // }
-    //
-    // if(config_filepath.empty()) {
-    //    llvm::errs() << "config file path is empty.\n";
-    //    return -1;
-    //} else {
-    //    auto toml = toml::parse_file(config_filepath);
-    //    auto frontend = toml["frontend"];
-    //    return 0;
-    //}
+    auto table = toml["server"];
+    if(table) {
+        if(auto mode = table["mode"]) {
+            config.server.mode = mode.as_string()->get();
+        }
+
+        if(auto port = table["port"]) {
+            config.server.port = port.as_integer()->get();
+        }
+
+        if(auto address = table["address"]) {
+            config.server.address = address.as_string()->get();
+        }
+
+        llvm::outs() << "Server:" << json::serialize(config.server) << "\n";
+    }
     return 0;
 }
 
diff --git a/src/Server/Server.cpp b/src/Server/Server.cpp
index fd3f86c5..ba991233 100644
--- a/src/Server/Server.cpp
+++ b/src/Server/Server.cpp
@@ -6,115 +6,202 @@
 
 namespace clice {
 
-static uv_loop_t* loop;
-static uv_idle_t idle;
-static uv_stream_t* writer;
+namespace {
 
-void schedule() {}
+class MessageBuffer {
+public:
+    MessageBuffer() = default;
 
-void on_alloc_buffer(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf) {
-    static llvm::SmallString<4096> buffer;
-    buffer.resize_for_overwrite(suggested_size);
-    buf->base = buffer.data();
-    buf->len = suggested_size;
-}
-
-void on_read(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf) {
-    if(nread > 0) {
-        llvm::outs() << "Received from stdin: " << llvm::StringRef(buf->base, nread);
-    } else if(nread < 0) {
-        if(nread != UV_EOF) {
-            fprintf(stderr, "Error reading from stdin: %s\n", uv_strerror(nread));
-        }
-        uv_close((uv_handle_t*)stream, NULL);
+    void append(llvm::StringRef message) {
+        buffer += message;
     }
-}
 
-void on_write(uv_write_t* req, int status) {
-    if(status < 0) {
-        fprintf(stderr, "Write error: %s\n", uv_strerror(status));
-    } else {
-        printf("Write completed successfully.\n");
+    llvm::StringRef peek() {
+        llvm::StringRef str = buffer;
+        std::size_t length = 0;
+        if(str.consume_front("Content-Length: ") && !str.consumeInteger(10, length) &&
+           str.consume_front("\r\n\r\n") && str.size() >= length) {
+            auto result = str.substr(0, length);
+            pos = str.end() - buffer.begin();
+            return result;
+        }
+        return {};
     }
-    free(req);
+
+    void consume() {
+        buffer.erase(buffer.begin(), buffer.begin() + pos);
+        pos = 0;
+    }
+
+private:
+    std::size_t pos;
+    llvm::SmallString<4096> buffer;
+};
+
+}  // namespace
+
+void Server::run(llvm::unique_function<void()> callback) {
+    this->callback = std::move(callback);
+    uv_run(uv_default_loop(), UV_RUN_DEFAULT);
 }
 
-void write(llvm::StringRef message) {
-    /// FIXME:
-    static uv_write_t write_req;
-    uv_buf_t buf = uv_buf_init((char*)message.data(), message.size());
-    uv_write(&write_req, writer, &buf, 1, on_write);
-}
+Server::Server(const config::ServerOption& option) {
 
-uv_stream_t* init_socket(const char* address, unsigned int port) {
-    static uv_tcp_t server;
-    static uv_tcp_t client;
+    static uv_loop_t* loop = uv_default_loop();
+    static uv_idle_t idle;
 
-    uv_tcp_init(loop, &server);
-    uv_tcp_init(loop, &client);
-
-    struct sockaddr_in addr;
-    uv_ip4_addr(address, port, &addr);
-
-    uv_tcp_bind(&server, (const struct sockaddr*)&addr, 0);
-
-    int r = uv_listen((uv_stream_t*)&server, 128, [](uv_stream_t* server, int status) {
-        if(status < 0) {
-            fprintf(stderr, "New connection error\n");
-            return;
-        }
-
-        if(uv_accept(server, (uv_stream_t*)&client) == 0) {
-            printf("Client connected.\n");
-            uv_read_start((uv_stream_t*)&client, on_alloc_buffer, on_read);
-        } else {
-            uv_close((uv_handle_t*)&client, NULL);
-        }
+    /// start the idle loop.
+    uv_idle_init(loop, &idle);
+    idle.data = this;
+    uv_idle_start(&idle, [](uv_idle_t* handle) {
+        auto& server = *static_cast<Server*>(handle->data);
+        server.callback();
     });
 
-    if(r) {
-        fprintf(stderr, "Listen error: %s\n", uv_strerror(r));
-    }
+    static auto on_alloc = +[](uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf) {
+        static llvm::SmallString<4096> buffer;
+        buffer.resize_for_overwrite(suggested_size);
+        buf->base = buffer.data();
+        buf->len = suggested_size;
+    };
 
-    return (uv_stream_t*)&client;
-}
+    static auto on_read = [](uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf) {
+        if(nread > 0) {
+            static MessageBuffer messageBuffer;
+            messageBuffer.append({buf->base, static_cast<std::size_t>(nread)});
+            if(auto message = messageBuffer.peek(); !message.empty()) {
+                auto& server = *static_cast<Server*>(stream->data);
+                if(auto json = json::parse(message)) {
+                    server.messages.emplace_back(*json);
+                    messageBuffer.consume();
+                } else {
+                    llvm::errs() << "JSON PARSE ERROR " << json.takeError() << "\n";
+                }
+            }
+        } else if(nread < 0) {
+            if(nread != UV_EOF) {
+                fprintf(stderr, "Error reading from stdin: %s\n", uv_strerror(nread));
+            }
+            uv_close((uv_handle_t*)stream, NULL);
+        }
+    };
 
-uv_stream_t* init_pipe() {
-    static uv_pipe_t stdin_pipe;
-    static uv_pipe_t stdout_pipe;
-
-    uv_pipe_init(loop, &stdin_pipe, 0);
-    uv_pipe_init(loop, &stdout_pipe, 0);
-
-    uv_pipe_open(&stdin_pipe, 0);
-    uv_pipe_open(&stdout_pipe, 1);
-
-    uv_read_start((uv_stream_t*)&stdin_pipe, on_alloc_buffer, on_read);
-
-    return (uv_stream_t*)&stdout_pipe;
-}
-
-int run(int argc, const char** argv) {
-    loop = uv_default_loop();
-
-    uv_idle_init(loop, &idle);
-    uv_idle_start(&idle, [](uv_idle_t* handle) { schedule(); });
-
-    /// read config file.
-    config::parse(argc, argv);
-
-    /// init writer.
-    const auto& option = config::server();
+    /// initialize the socket or pipe.
     if(option.mode == "socket") {
-        writer = init_socket(option.address.c_str(), option.port);
+        static uv_tcp_t server;
+        static uv_tcp_t client;
+
+        uv_tcp_init(loop, &server);
+        uv_tcp_init(loop, &client);
+        server.data = this;
+        client.data = this;
+
+        struct sockaddr_in addr;
+        /// FIXME:
+        uv_ip4_addr(option.address.c_str(), option.port, &addr);
+
+        uv_tcp_bind(&server, (const struct sockaddr*)&addr, 0);
+        int r = uv_listen((uv_stream_t*)&server, 128, [](uv_stream_t* server, int status) {
+            if(status < 0) {
+                llvm::errs() << "New connection error\n";
+                return;
+            }
+
+            if(uv_accept(server, (uv_stream_t*)&client) == 0) {
+                llvm::errs() << "Client connected.\n";
+                uv_read_start((uv_stream_t*)&client, on_alloc, on_read);
+            } else {
+                uv_close((uv_handle_t*)&client, NULL);
+            }
+        });
+
+        if(r) {
+            llvm::errs() << "Listen error: " << uv_strerror(r) << "\n";
+        }
+
+        writer = (uv_stream_t*)&client;
     } else if(option.mode == "pipe") {
-        writer = init_pipe();
+        static uv_pipe_t stdin_pipe;
+        static uv_pipe_t stdout_pipe;
+
+        uv_pipe_init(loop, &stdin_pipe, 0);
+        uv_pipe_init(loop, &stdout_pipe, 0);
+        stdin_pipe.data = this;
+        stdout_pipe.data = this;
+
+        uv_pipe_open(&stdin_pipe, 0);
+        uv_pipe_open(&stdout_pipe, 1);
+
+        uv_read_start((uv_stream_t*)&stdin_pipe, on_alloc, on_read);
+
+        writer = (uv_stream_t*)&stdout_pipe;
     } else {
         llvm::errs() << "Unknown mode: " << option.mode << "\n";
-        return 1;
     }
-
-    return uv_run(loop, UV_RUN_DEFAULT);
 }
 
+void Server::write(llvm::StringRef message) {
+    uv_write_t* req = new uv_write_t();
+    uv_buf_t buf = uv_buf_init(const_cast<char*>(message.data()), message.size());
+
+    auto on_write = [](uv_write_t* req, int status) {
+        if(status < 0) {
+            llvm::errs() << "Write error: " << uv_strerror(status) << "\n";
+        }
+        delete req;
+    };
+
+    uv_write(req, static_cast<uv_stream_t*>(writer), &buf, 1, on_write);
+}
+
+void Server::request() {}
+
+void Server::response(json::Value id, json::Value result) {
+    json::Value response = json::Object{
+        {"jsonrpc", "2.0" },
+        {"id",      id    },
+        {"result",  result},
+    };
+
+    struct Buffer {
+        llvm::SmallString<128> header;
+        llvm::SmallString<4096> message;
+    };
+
+    Buffer* buffer = new Buffer();
+
+    llvm::raw_svector_ostream os(buffer->message);
+    os << response;
+
+    llvm::raw_svector_ostream sos(buffer->header);
+    sos << "Content-Length: " << buffer->message.size() << "\r\n\r\n";
+
+    uv_buf_t bufs[2] = {
+        uv_buf_init(buffer->header.data(), buffer->header.size()),
+        uv_buf_init(buffer->message.data(), buffer->message.size()),
+    };
+
+    uv_write_t* req = new uv_write_t();
+    req->data = buffer;
+
+    auto on_write = [](uv_write_t* req, int status) {
+        if(status < 0) {
+            llvm::errs() << "Write error: " << uv_strerror(status) << "\n";
+        }
+
+        delete static_cast<Buffer*>(req->data);
+        delete req;
+    };
+
+    int r = uv_write(req, static_cast<uv_stream_t*>(writer), bufs, 2, on_write);
+
+    if(r) {
+        llvm::errs() << "Write error: " << uv_strerror(r) << "\n";
+    }
+}
+
+void Server::notify() {}
+
+void Server::error() {}
+
 }  // namespace clice
diff --git a/src/main.cpp b/src/main.cpp
index ef1b8aa8..bc6c2e23 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1,6 +1,45 @@
 #include "Server/Server.h"
+#include "llvm/Support/CommandLine.h"
+
+namespace clice {}
+
+using namespace clice;
 
 int main(int argc, const char** argv) {
-    clice::run(argc, argv);
+    llvm::cl::opt<std::string> config("config");
+    llvm::cl::ParseCommandLineOptions(argc, argv);
+
+    if(!config.hasArgStr()) {
+        llvm::errs() << "Missing config file.\n";
+        std::terminate();
+    }
+
+    llvm::outs() << "Config file: " << config << "\n";
+
+    config::parse(argv[0], config);
+
+    Server server(config::server());
+    auto loop = [&server]() {
+        if(server.hasMessage()) {
+            auto& json = server.peek();
+            assert(json.kind() == json::Value::Object);
+            auto object = json.getAsObject();
+
+            if(auto method = object->get("method")) {
+                assert(method->kind() == json::Value::String);
+                auto name = method->getAsString();
+                if(name == "initialize") {
+                    assert(object->get("params"));
+                    auto params =
+                        json::deserialize<proto::InitializeParams>(*object->get("params"));
+                    llvm::outs() << "Initialize: " << params.workspaceFolders[0].uri << "\n";
+                    server.response(std::move(*object->get("id")),
+                                    json::serialize(proto::InitializeResult{}));
+                    server.consume();
+                }
+            }
+        }
+    };
+    server.run(loop);
     return 0;
 }
diff --git a/tests/ASTVisitor/macro.cpp b/tests/ASTVisitor/macro.cpp
index c9d2b8c9..86b3b6fd 100644
--- a/tests/ASTVisitor/macro.cpp
+++ b/tests/ASTVisitor/macro.cpp
@@ -1,11 +1,14 @@
-#define Name name
-#define SELF(x) x
-#define SELF3(x) X
+#define TEST(name)                                                                                 \
+    struct name {};                                                                                \
+    struct name2 {};                                                                               \
+    struct name##3 {};                                                                             \
+    struct name name;
 
-void Name() {}
+TEST(name);
 
-int SELF(x) = 1;
+int main() {
+    struct name x;
+    struct name2 y;
+    struct name3 z;
+}
 
-void SELF3(x)() {}
-
-int z = SELF(x) + SELF(x);
\ No newline at end of file
diff --git a/tests/ASTVisitor/test.cpp b/tests/ASTVisitor/test.cpp
index 654a287a..e69de29b 100644
--- a/tests/ASTVisitor/test.cpp
+++ b/tests/ASTVisitor/test.cpp
@@ -1,7 +0,0 @@
-template <typename T>
-void foo() {
-    typename T::type::type::type x;
-    T::x = 1;
-    T::x.y = 2;
-    typename T::type::type::name y;
-}
diff --git a/unittests/AST/ASTVisitor.cpp b/unittests/AST/ASTVisitor.cpp
index 422f4a70..cf77f4d2 100644
--- a/unittests/AST/ASTVisitor.cpp
+++ b/unittests/AST/ASTVisitor.cpp
@@ -2,9 +2,10 @@
 #include <Support/JSON.h>
 #include <Compiler/Compiler.h>
 #include <Support/FileSystem.h>
-#include <Compiler//Utility.h>
+#include <Compiler/Utility.h>
 #include "../Test.h"
 #include "clang/AST/DeclTemplate.h"
+#include "Compiler/Semantic.h"
 
 namespace {
 
@@ -12,93 +13,51 @@ using namespace clice;
 
 class ASTVisitor : public clang::RecursiveASTVisitor<ASTVisitor> {
 public:
+    Compiler& compiler;
     clang::SourceManager& srcMgr;
+    clang::Sema& sema;
 
-    ASTVisitor(clang::SourceManager& srcMgr) : srcMgr(srcMgr) {}
+    ASTVisitor(Compiler& compiler, clang::SourceManager& srcMgr, clang::Sema& sema) :
+        compiler(compiler), srcMgr(srcMgr), sema(sema) {}
 
     using Base = clang::RecursiveASTVisitor<ASTVisitor>;
 
-    bool VisitDependentNameTypeLoc(clang::DependentNameTypeLoc loc) {
-        loc.getNameLoc().dump(srcMgr);
-        /// loc.dump();
-        return true;
+    void dump(clang::SourceLocation loc) {
+        if(loc.isMacroID()) {
+            llvm::outs() << "expansion: ";
+            srcMgr.getExpansionLoc(loc).print(llvm::outs(), srcMgr);
+            llvm::outs() << "\n";
+
+            llvm::outs() << "spelling: ";
+            srcMgr.getSpellingLoc(loc).print(llvm::outs(), srcMgr);
+            llvm::outs() << "\n";
+
+            llvm::outs() << "file: ";
+            srcMgr.getFileLoc(loc).print(llvm::outs(), srcMgr);
+            llvm::outs() << "\n";
+
+            auto [begin, end] = srcMgr.getImmediateExpansionRange(loc).getAsRange();
+            if(begin.isValid() && end.isValid()) {
+                llvm::outs() << "expansion Range: \n";
+                dump(begin);
+                dump(end);
+                llvm::outs() << "\n";
+            }
+
+            llvm::outs() << "\n";
+        }
     }
 
+    // bool VisitTemplateSpecializationTypeLoc(clang::TemplateSpecializationTypeLoc loc) {
+    //     loc.dump();
+    //     return true;
+    // }
+
     bool VisitDependentScopeDeclRefExpr(clang::DependentScopeDeclRefExpr* expr) {
         expr->dump();
-        
-        return true;
-    }
-
-    bool VisitCXXDependentScopeMemberExpr(clang::CXXDependentScopeMemberExpr* expr) {
-        expr->dump();
-        return true;
-    }
-
-    bool TraverseNestedNameSpecifierLoc(clang::NestedNameSpecifierLoc loc) {
-        if(!loc) {
-            return true;
+        for(auto member: compiler.resolver().lookup(expr)) {
+            member->dump();
         }
-
-        auto NNS = loc.getNestedNameSpecifier();
-        switch(NNS->getKind()) {
-            case clang::NestedNameSpecifier::Identifier: {
-                loc.getLocalSourceRange().dump(srcMgr);
-                llvm::outs() << NNS << "\n";
-                break;
-            }
-        }
-        return Base::TraverseNestedNameSpecifierLoc(loc);
-    }
-
-    bool $VisitFunctionTemplateDecl(clang::FunctionTemplateDecl* decl) {
-        for(auto spec: decl->specializations()) {
-            spec->getLocation().dump(srcMgr);
-            spec->getFunctionTypeLoc().getReturnLoc().getLocalSourceRange().dump(srcMgr);
-            spec->getQualifierLoc().getSourceRange().dump(srcMgr);
-
-            auto info = spec->getTemplateSpecializationInfo();
-            info->PointOfInstantiation.dump(srcMgr);
-            llvm::outs() << info->TemplateArguments << "\n";
-            llvm::outs() << info->TemplateArgumentsAsWritten << "\n";
-        }
-        return true;
-    }
-
-    bool VisitVarTemplateSpecializationDecl(clang::VarTemplateSpecializationDecl* decl) {
-        decl->dump();
-        decl->getTypeSourceInfo()->getTypeLoc().getSourceRange().dump(srcMgr);
-        return true;
-    }
-
-    bool $VisitNamedDecl(clang::NamedDecl* decl) {
-        auto loc = decl->getLocation();
-        /// is the token generated from a macro argument?
-        llvm::outs() << "is in macro arg: " << srcMgr.isMacroArgExpansion(loc) << "\n";
-        llvm::outs() << "is in macro body: " << srcMgr.isMacroBodyExpansion(loc) << "\n";
-        auto range = srcMgr.getImmediateExpansionRange(loc);
-        auto rang2 = srcMgr.getImmediateMacroCallerLoc(loc);
-        decl->getLocation().dump(srcMgr);
-        return true;
-    };
-
-    bool $VisitTemplateSpecializationTypeLoc(clang::TemplateSpecializationTypeLoc loc) {
-        auto RD = loc.getType()->getAsCXXRecordDecl();
-        llvm::outs() << loc.getTypePtr()->getTemplateName().getAsTemplateDecl()->getCanonicalDecl()
-                     << "\n";
-        llvm::outs() << loc.getType().getAsString() << "\n";
-        instantiatedFrom(RD)->dump();
-        llvm::outs() << "------------------------------------------------\n";
-        return true;
-    }
-
-    bool $VisitMemberExpr(clang::MemberExpr* expr) {
-        expr->getMemberDecl()->dump();
-        // llvm::outs() << "is in macro arg: " << srcMgr.isMacroArgExpansion(loc) << "\n";
-        // llvm::outs() << "is in macro body: " << srcMgr.isMacroBodyExpansion(loc) << "\n";
-        // auto range = srcMgr.getImmediateExpansionRange(loc);
-        // auto rang2 = srcMgr.getImmediateMacroCallerLoc(loc);
-        // expr->getLocation().dump(srcMgr);
         return true;
     }
 };
@@ -115,9 +74,12 @@ TEST(clice, ASTVisitor) {
             };
             Compiler compiler(compileArgs);
             compiler.buildAST();
-            ASTVisitor visitor(compiler.srcMgr());
+
+            SemanticVisitor visitor(compiler);
             visitor.TraverseAST(compiler.context());
-            // compiler.tu()->dump();
+            // ASTVisitor visitor(compiler, compiler.srcMgr(), compiler.sema());
+            // visitor.TraverseAST(compiler.context());
+            //  compiler.tu()->dump();
         }
     });
 }
diff --git a/unittests/AST/SemanticVisitor.cpp b/unittests/AST/SemanticVisitor.cpp
new file mode 100644
index 00000000..a7d79367
--- /dev/null
+++ b/unittests/AST/SemanticVisitor.cpp
@@ -0,0 +1,10 @@
+#include "Compiler/Semantic.h"
+
+#include "../Test.h"
+
+namespace clice {
+
+namespace {}  // namespace
+
+}  // namespace clice
+