diff --git a/notebooks/eval_json.ipynb b/notebooks/eval_json.ipynb
new file mode 100644
index 00000000..16019d8c
--- /dev/null
+++ b/notebooks/eval_json.ipynb
@@ -0,0 +1,86 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/shubham/anaconda3/envs/codex/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n",
+      "Loading checkpoint shards: 100%|██████████| 2/2 [00:00<00:00, 11.83it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Running Gemma-2-2b-it on JSON evaluation from nousResearch/json-mode-eval\n",
+    "import sys, os\n",
+    "sys.path.append(os.getcwd() + '/../')\n",
+    "from syncode import Syncode\n",
+    "\n",
+    "syn_llm = Syncode(\n",
+    "    mode=\"grammar_mask\",\n",
+    "    model=\"google/gemma-2-2b-it\",\n",
+    "    grammar=\"json\",\n",
+    "    max_new_tokens=400,\n",
+    "    parser=\"lr\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 100/100 [07:50<00:00,  4.71s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Result: {'pass@1': 0.99}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "result = syn_llm.evaluate(dataset=\"json_eval\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "codex",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/notebooks/example_date.ipynb b/notebooks/example_date.ipynb
index f5eb7a30..851e0007 100644
--- a/notebooks/example_date.ipynb
+++ b/notebooks/example_date.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 1,
    "id": "ffd1e5da",
    "metadata": {},
    "outputs": [
@@ -10,17 +10,25 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "Loading checkpoint shards:   0%|          | 0/2 [00:00<?, ?it/s]"
+      "/home/shubham/anaconda3/envs/codex/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n",
+      "Loading checkpoint shards: 100%|██████████| 2/2 [00:00<00:00,  3.61it/s]\n",
+      "Loading checkpoint shards: 100%|██████████| 2/2 [00:00<00:00,  3.69it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Creating DFA mask store for CodeGenTokenizerFast and custom, may take more than 10 minutes. Caching at /home/shubham/syncode/cache/mask_stores/CodeGenTokenizerFast/grammar_strict_1140931734_50257.pkl.\n",
+      "Ignore whitespace tokens is False\n"
      ]
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "Loading checkpoint shards: 100%|██████████| 2/2 [00:00<00:00,  4.00it/s]\n",
-      "Special tokens have been added in the vocabulary, make sure the associated word embeddings are fine-tuned or trained.\n",
-      "Loading checkpoint shards: 100%|██████████| 2/2 [00:00<00:00,  4.08it/s]\n",
-      "Special tokens have been added in the vocabulary, make sure the associated word embeddings are fine-tuned or trained.\n"
+      "100%|██████████| 96/96 [00:24<00:00,  3.89it/s]\n"
      ]
     }
    ],
@@ -45,10 +53,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 2,
    "id": "f3f9f3b8",
    "metadata": {},
    "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "We detected that you are passing `past_key_values` as a tuple and this is deprecated and will be removed in v4.43. Please use an appropriate `Cache` class (https://huggingface.co/docs/transformers/v4.41.3/en/internal/generation_utils#transformers.Cache)\n"
+     ]
+    },
     {
      "name": "stdout",
      "output_type": "stream",
@@ -73,7 +88,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 3,
    "id": "4bf95c2b",
    "metadata": {},
    "outputs": [
@@ -101,7 +116,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 4,
    "id": "3ad2158b",
    "metadata": {},
    "outputs": [
diff --git a/syncode/common.py b/syncode/common.py
index c4de64ee..2be53afc 100644
--- a/syncode/common.py
+++ b/syncode/common.py
@@ -1,11 +1,6 @@
 import os
-from transformers import (
-    LlamaTokenizer,
-    LlamaForCausalLM,
-    AutoTokenizer,
-    AutoModelForCausalLM,
-)
 import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
 
 # Remove this in future and add instruction to set the HF_CACHE env variable
 RESULTS_DIR = os.environ['RESULTS_DIR'] if 'RESULTS_DIR' in os.environ else 'results/'
@@ -52,6 +47,12 @@ def load_tokenizer(model_name):
             tokenizer = AutoTokenizer.from_pretrained(model_name, cache_dir=HF_CACHE, token=HF_ACCESS_TOKEN, trust_remote_code=True)
         return tokenizer
 
+def get_output_path(model_name, grammar, dataset, num_samples, mode):
+        out_dir = f"results/{model_name}/{grammar}/{dataset}/"
+        out_path = out_dir + 'samples_' + str(num_samples) + '_mode_' + str(mode) + "_eval.jsonl"
+        os.makedirs(out_dir, exist_ok=True)
+        return out_dir,out_path
+
 class Logger:
     """
     Logger class for logging the output of the model
@@ -135,4 +136,7 @@ def log_error(self, msg):
         pass
     def close(self):
         pass
-
+    def is_closed(self):
+        return False
+    def open(self):
+        pass
diff --git a/syncode/evaluation/code_eval.py b/syncode/evaluation/code_eval.py
index ddbd52d2..28f79d1f 100644
--- a/syncode/evaluation/code_eval.py
+++ b/syncode/evaluation/code_eval.py
@@ -2,6 +2,7 @@
 import time
 from tqdm import tqdm
 from typing import Optional
+from syncode import common
 from syncode.evaluation.mxeval_evaluation import check_coorectness
 from mxeval.data import write_jsonl
 
@@ -14,9 +15,10 @@ class CodeEval:
     def run_code_eval(
         syncode, 
         num_samples_per_task: int,
-        out_path: str,
+        out_path: Optional[str]=None,
         format_tabs: bool = False,
-        debug_task_id: Optional[int] = None
+        debug_task_id: Optional[int] = None,
+        logger=common.EmptyLogger()
         ):
         problems = syncode.dataset.problems
 
@@ -27,23 +29,25 @@ def run_code_eval(
             time1 = time.time()
             for task_id in problems:
                 outputs.append(CodeEval.run_eval_for_task(syncode, num_samples_per_task, format_tabs, problems, samples, pbar, task_id))
-            write_jsonl(out_path, samples)
+            
+            if out_path is not None: write_jsonl(out_path, samples)
+            
             avg_time = (time.time() - time1) / len(problems)
-            functional_result = check_coorectness(out_path, logger=syncode.logger)
-            syncode.logger.log(f"Functional result: {functional_result}")
+            functional_result = check_coorectness(out_path, logger=logger)
+            logger.log(f"Functional result: {functional_result}")
 
             # Also log these results in a separate file
             CodeEval.write_results(syncode, out_path, avg_time, functional_result)
         else: # Debugging a specific task
             debug_task_id = list(problems.keys())[debug_task_id]
-            return CodeEval.run_eval_for_task(syncode, num_samples_per_task, format_tabs, problems, samples, pbar, debug_task_id)
+            return CodeEval.run_eval_for_task(syncode, num_samples_per_task, format_tabs, problems, samples, pbar, debug_task_id, logger=logger)
         return outputs
 
-    def run_eval_for_task(syncode, num_samples_per_task, format_tabs, problems, samples, pbar, task_id):
+    def run_eval_for_task(syncode, num_samples_per_task, format_tabs, problems, samples, pbar, task_id, logger=common.EmptyLogger()):
         """
         run evaluation for a specific task
         """
-        syncode.logger.log(f"Running eval for task {task_id}")
+        logger.log(f"Running eval for task {task_id}")
 
         if format_tabs:
             prompt = problems[task_id]["prompt"].replace("    ", "\t")
diff --git a/syncode/evaluation/fol_eval.py b/syncode/evaluation/fol_eval.py
index 60500286..a747a12b 100644
--- a/syncode/evaluation/fol_eval.py
+++ b/syncode/evaluation/fol_eval.py
@@ -3,6 +3,7 @@
 """
 import random
 import re
+from typing import Optional
 from mxeval.data import write_jsonl
 from tqdm import tqdm
 import signal
@@ -77,7 +78,7 @@
 
 class FOLEval:
     @staticmethod
-    def run_eval(syncode, debug_task_id=None):
+    def run_eval(syncode, out_path: Optional[str]=None, debug_task_id=None):
         problems = syncode.dataset.problems[:100]
         if debug_task_id is not None:
             problems = [problems[debug_task_id]]
@@ -152,8 +153,9 @@ def run_eval(syncode, debug_task_id=None):
             count_syn_error += (not is_parsed)
             samples += [res]
             pbar.update(syncode.num_samples)
-
-        write_jsonl(syncode.out_path, samples)
+        
+        if out_path is not None: write_jsonl(out_path, samples)
+        
         print(f"Pass rate: {count_pass}/{len(problems)}")
         print(f"Compilation error rate: {count_compile_error}/{len(problems)}")
         print(f"Execution error rate: {count_exec_error}/{len(problems)}")
diff --git a/syncode/evaluation/json_eval.py b/syncode/evaluation/json_eval.py
index 0c72aee5..7911aa9d 100644
--- a/syncode/evaluation/json_eval.py
+++ b/syncode/evaluation/json_eval.py
@@ -5,6 +5,7 @@
 import json
 from jsonschema import validate, ValidationError
 from collections import defaultdict
+from syncode import common
 from syncode.evaluation.mxeval_evaluation import compute_pass_at_k
 
 class JSONEval:
@@ -13,8 +14,10 @@ class JSONEval:
     """
     @staticmethod
     def run_json_eval(
-        syncode, 
+        syncode,
+        out_path: Optional[str], 
         debug_task_id: Optional[int] = None,
+        logger=common.EmptyLogger()
         ):
         problems = syncode.dataset.problems
         if syncode.grammar_decoder is not None:
@@ -35,19 +38,19 @@ def run_json_eval(
                 return output
             outputs.append(outputs) 
 
-        schema_result = validate_json_data(syncode, samples, results)
+        schema_result = validate_json_data(syncode, samples, results, logger=logger)
 
         # exact match evaluation doesn't make sense
-        # exact_match_result = validate_json_completion(syncode, samples, results)
-
-        write_jsonl(syncode.out_path, schema_result)
+        # exact_match_result = validate_json_completion(samples, results, logger=logger)
+        if out_path is not None:
+            write_jsonl(out_path, schema_result)
         
         pass_at_k = compute_pass_at_k(results)
 
         # Log result
-        syncode.logger.log(f"Result: {pass_at_k}")
+        logger.log(f"Result: {pass_at_k}")
         print(f"Result: {pass_at_k}")
-        syncode.logger.close()
+        logger.close()
         return outputs
     
     def run_eval_for_task(syncode, num_samples_per_task, problem, samples, pbar, task_id):
@@ -70,7 +73,7 @@ def run_eval_for_task(syncode, num_samples_per_task, problem, samples, pbar, tas
         pbar.update(num_samples_per_task)
         return batch_completions
     
-def validate_json_data(syncode, samples, results):
+def validate_json_data(syncode, samples, results, logger=common.EmptyLogger()):
     validation_results = []
     for sample in samples:
         valid = False
@@ -90,7 +93,7 @@ def validate_json_data(syncode, samples, results):
                 except (SyntaxError, ValueError) as e:
                     generated_json = json_object
                     error_message = f"JSON decoding error: {e}"
-                    syncode.logger.log(f"Validation failed for JSON data: {error_message}")
+                    logger.log(f"Validation failed for JSON data: {error_message}")
                     validation_results.append(dict(task_id = sample["task_id"], completion = generated_json, schema = json_schema, ground_truth = None, result = error_message, passed = valid, error_type = "Decoding Error"))
                     results[sample["task_id"]].append((sample["completion_id"], dict(task_id= sample["task_id"], completion= sample["completion"], passed= valid)))
                     continue
@@ -99,7 +102,7 @@ def validate_json_data(syncode, samples, results):
                 for index, item in enumerate(generated_json):
                     try:
                         validate(instance=item, schema=json_schema)
-                        syncode.logger.log(f"Item {index+1} is valid against the schema.")
+                        logger.log(f"Item {index+1} is valid against the schema.")
                     except ValidationError as e:
                         error_message = f"Validation failed for item {index+1}: {e}"
                         break
@@ -116,16 +119,13 @@ def validate_json_data(syncode, samples, results):
             valid = True
             error_message = "JSON data is valid against the schema."
             error_type = "No Error"
-            syncode.logger.log(error_message)
-        else:
-            syncode.logger.log(f"Validation failed for JSON data: {error_message}")
     
         validation_results.append(dict(task_id = sample["task_id"], completion = generated_json, schema = json_schema, ground_truth = None, result = error_message, passed = valid, error_type = error_type))
         results[sample["task_id"]].append((sample["completion_id"], dict(task_id= sample["task_id"], completion= sample["completion"], passed= valid)))
 
     return validation_results
 
-def validate_json_completion(syncode, samples, results):
+def validate_json_completion(samples, results, logger=common.EmptyLogger()):
     validation_results = []
     for sample in samples:
         json_object = sample["completion"]
@@ -141,16 +141,16 @@ def validate_json_completion(syncode, samples, results):
                 except (SyntaxError, ValueError) as e:
                     generated_json = json_object
                     error_message = f"JSON decoding error: {e}"
-                    syncode.logger.log(f"Validation failed for JSON data: {error_message}")
+                    logger.log(f"Validation failed for JSON data: {error_message}")
                     validation_results.append(dict(task_id = sample["task_id"], completion = generated_json, schema = None, ground_truth = ground_truth_json, result = error_message, passed = valid, error_type = "Decoding Error"))
                     results[sample["task_id"]].append((sample["completion_id"], dict(task_id= sample["task_id"], completion= sample["completion"], passed= valid)))
                     continue
             
             
             if set(generated_json.keys()) != set(ground_truth_json.keys()):
-                syncode.logger.log("Keys don't match:")
-                syncode.logger.log(f"Expected: {set(generated_json.keys())}")
-                syncode.logger.log(f"Got: {set(ground_truth_json.keys())}")
+                logger.log("Keys don't match:")
+                logger.log(f"Expected: {set(generated_json.keys())}")
+                logger.log(f"Got: {set(ground_truth_json.keys())}")
                 error_message = f"Keys don't match: Expected: {set(generated_json.keys())} Got: {set(ground_truth_json.keys())}"
                 validation_results.append(dict(task_id = sample["task_id"], completion = generated_json, schema = None, ground_truth = ground_truth_json, result = error_message, passed = valid, error_type = "Key Match Error"))
                 results[sample["task_id"]].append((sample["completion_id"], dict(task_id= sample["task_id"], completion= sample["completion"], passed= valid)))
@@ -158,9 +158,9 @@ def validate_json_completion(syncode, samples, results):
 
             for key in generated_json.keys():
                 if generated_json[key] != ground_truth_json[key]:
-                    syncode.logger.log(f"Values don't match for key '{key}'")
-                    syncode.logger.log(f"Expected: {generated_json[key]}")
-                    syncode.logger.log(f"Got: {ground_truth_json[key]}")
+                    logger.log(f"Values don't match for key '{key}'")
+                    logger.log(f"Expected: {generated_json[key]}")
+                    logger.log(f"Got: {ground_truth_json[key]}")
                     error_message = f"Values don't match for key '{key}' Expected: {generated_json[key]} Got: {ground_truth_json[key]}"
                     validation_results.append(dict(task_id = sample["task_id"], completion = generated_json, schema = None, ground_truth = ground_truth_json, result = error_message, passed = valid, error_type = "Value Match Error"))
                     results[sample["task_id"]].append((sample["completion_id"], dict(task_id= sample["task_id"], completion= sample["completion"], passed= valid)))
@@ -170,7 +170,7 @@ def validate_json_completion(syncode, samples, results):
                 continue
         
         except Exception as e:
-            syncode.logger.log(f"Exception occured: {e}")
+            logger.log(f"Exception occured: {e}")
             error_message = f"Error occurred: {e}"
             error_type = "Other Error"
             validation_results.append(dict(task_id = sample["task_id"], completion = generated_json, schema = None, ground_truth = ground_truth_json, result = error_message, passed = valid, error_type = error_type))
diff --git a/syncode/evaluation/math_eval.py b/syncode/evaluation/math_eval.py
index 1d952e28..96a088cc 100644
--- a/syncode/evaluation/math_eval.py
+++ b/syncode/evaluation/math_eval.py
@@ -1,5 +1,7 @@
 import time
+from typing import Optional
 from tqdm import tqdm
+from syncode import common
 from syncode.evaluation.mxeval_evaluation import compute_pass_at_k
 from mxeval.data import write_jsonl
 
@@ -9,7 +11,7 @@ class MathEval:
     Run evaluation on math question-answer dataset 
     """
     @staticmethod
-    def run_math_eval(syncode, debug_task_id=None):
+    def run_math_eval(syncode, out_path: Optional[str], debug_task_id=None, logger=common.EmptyLogger()):
         problems = syncode.dataset.problems
         if debug_task_id is not None:
             problems = [problems[debug_task_id]]
@@ -26,7 +28,7 @@ def run_math_eval(syncode, debug_task_id=None):
                 )
             for completion_id, raw_completion in enumerate(batch_completions):
                 completion = syncode.dataset.post_process_answer(raw_completion)
-                syncode.logger.log(f"\n\nProblem: {problem}\nCompletion: {completion}\n")
+                logger.log(f"\n\nProblem: {problem}\nCompletion: {completion}\n")
                 true_answer = float(problem['answer'].split('#')[-1].replace(',', ''))
                 llm_answer = None
                 try:
@@ -35,7 +37,7 @@ def run_math_eval(syncode, debug_task_id=None):
                     llm_answer = float(ans.split('#')[-1])
                 except:
                     pass
-                syncode.logger.log(f"True answer: {true_answer},\nLLM answer: {llm_answer}")
+                logger.log(f"True answer: {true_answer},\nLLM answer: {llm_answer}")
                 passed = (true_answer == llm_answer)
                 res = dict(
                     task_id=task_id,
@@ -46,13 +48,12 @@ def run_math_eval(syncode, debug_task_id=None):
                 results[task_id].append((completion_id, res))          
             pbar.update(syncode.num_samples)
 
-        write_jsonl(syncode.out_path, samples)
+        if out_path is not None: write_jsonl(out_path, samples)
         pass_at_k = compute_pass_at_k(results)
 
         # Log result and time
         avg_time = (time.time() - time1) / len(problems)
-        syncode.logger.log(f"Result: {pass_at_k}")
         print(f"Result: {pass_at_k}")
-        syncode.logger.close()
+        logger.log(f"Result: {pass_at_k}")
         return samples
     
\ No newline at end of file
diff --git a/syncode/evaluation/sql_eval.py b/syncode/evaluation/sql_eval.py
index 61d79fc3..de95c6a4 100644
--- a/syncode/evaluation/sql_eval.py
+++ b/syncode/evaluation/sql_eval.py
@@ -1,3 +1,4 @@
+from typing import Optional
 from tqdm import tqdm
 from mxeval.data import write_jsonl
 
@@ -7,13 +8,13 @@ class SQLEval:
     Run evaluation on SQL dataset
     """
     @staticmethod
-    def run_eval(syncode):
+    def run_eval(syncode, out_path: Optional[str]):
         problems = syncode.dataset.problems[:100]
         samples = []
         pbar = tqdm(total=len(problems) * syncode.num_samples)
         results = {}
         assert syncode.num_samples == 1, "SQL evaluation only supports num_samples=1"
-        predict_file = syncode.out_path
+        predict_file = out_path
 
         if syncode.grammar_decoder is not None:
             syncode.grammar_decoder.parse_output_only = True # Do not parse input+output
@@ -43,4 +44,5 @@ def run_eval(syncode):
         databses = "syncode/utils/sql_spider_eval/databases"
         scores, error_types = evaluate(predict_file, gold_file, databses, etype="all", table=tables, result_jsonl=samples)
         print(f"Scores: {scores['all']}\n Error types: {error_types}")
-        write_jsonl(syncode.out_path, samples)
+        
+        if out_path is not None: write_jsonl(out_path, samples)
diff --git a/syncode/infer.py b/syncode/infer.py
index a3ae3583..f823305b 100644
--- a/syncode/infer.py
+++ b/syncode/infer.py
@@ -15,8 +15,20 @@
 
 
 def compile_and_run(model, mode="grammar_strict", quantize=True, device="cuda", num_samples=1, grammar=None, dataset="input", num_few_shot=0, chat_mode=False, dev_mode=False, log_level=1, new_mask_store=False, parser="lalr", task_id=None, **kwargs):
-    sc = Syncode(model, mode=mode, quantize=quantize, device=device, num_samples=num_samples, grammar=grammar, dataset=dataset, num_few_shot=num_few_shot, chat_mode=chat_mode, dev_mode=dev_mode, log_level=log_level, new_mask_store=new_mask_store, parser=parser, task_id=task_id, **kwargs)
-    sc.infer(task_id=task_id)
+
+    syncode = Syncode(model, mode=mode, quantize=quantize, device=device, num_samples=num_samples, grammar=grammar, chat_mode=chat_mode, dev_mode=dev_mode, log_level=log_level, new_mask_store=new_mask_store, parser=parser, **kwargs)
+    
+    if dataset == "input":
+        syncode.infer()
+    else:
+        # Setup output directory and logger
+        out_dir, out_path = common.get_output_path(model, grammar, dataset, num_samples, mode)
+        logger = common.Logger(num_samples, mode, parser, out_dir, log_level=log_level, task_id=task_id)
+        if syncode.grammar_decoder is not None: syncode.grammar_decoder.logger = logger
+
+        # Run evaluation
+        syncode.evaluate(dataset=dataset, task_id=task_id, out_path=out_path, logger=logger, num_few_shot=num_few_shot)
+
 
 class Syncode:
     """Syncode class for running inference on a model
@@ -34,20 +46,16 @@ class Syncode:
         
         grammar (str, optional): Language. Defaults to "input". "input" is used for user input. 
             other options currently supported are "python", "go", "calc"
-        
-        dataset (str, optional): Dataset. Defaults to "humaneval".
-        
+                
         new_mask_store (bool, optional): Use new DFA mask store. Defaults to False.
-        
-        num_few_shot (int, optional): Number of examples for few shot prompting. Defaults to 0.
-        
+                
         chat_mode (bool, optional): Parse only the (output) and not (prompt+output) in chat mode. Defaults to False.
         
         dev_mode (bool, optional): Development mode. Defaults to False.
+
         log_level (int, optional): Log level. Defaults to 2. 0 for no logs, 1 for minimal logs, 2 for all logs including time.
         
         parser (str, optional): Parser to use. Defaults to "lalr".
-        task_id (int, optional): For debugging a specific task. Defaults to None.
     """
     def __init__(
         self, 
@@ -57,15 +65,12 @@ def __init__(
         device: str = "cuda",
         num_samples: int = 1,
         grammar: Optional[str] = None,
-        dataset: Literal["mbxp", "humaneval", "mathqa-x", "input", "gsm8k", "spider", "json_eval"] = "input",
-        num_few_shot: int = 0,
         chat_mode: bool = False,
         parse_output_only: bool = False,
         dev_mode: bool = False,
         log_level: int = 1,
         new_mask_store: bool = False,
         parser: Literal["lr", "lalr"] = "lalr",
-        task_id: Optional[int] = None,
         **kwargs
     ):  
         # Check inputs
@@ -81,9 +86,9 @@ def __init__(
         self.device = device
         self.num_samples = num_samples
         self.new_mask_store = new_mask_store
-        self.num_few_shot = num_few_shot
         self.parser = parser
         self.chat_mode = chat_mode
+        self.log_level = log_level
 
         if self.chat_mode:
             self.parse_output_only = True
@@ -93,17 +98,10 @@ def __init__(
         # Set the grammar
         self.grammar = Grammar(grammar) if self.is_grammar_mode() else None
 
-        # Load the dataset
-        self.dataset = Dataset(dataset, language=grammar, num_few_shot=num_few_shot)
-
         # Load model
         model = common.load_model(self.model_name, device, quantize)
         tokenizer = common.load_tokenizer(self.model_name)
         
-        # Setup output directory
-        out_dir, self.out_path = self.get_output_path()
-        self.logger = common.Logger(self.num_samples, mode, parser, out_dir, log_level=log_level, task_id=task_id)
-        
         # Initialize logit processors
         self.grammar_decoder = None
         
@@ -111,7 +109,6 @@ def __init__(
             self.grammar_decoder = SyncodeLogitsProcessor(
                 self.grammar, 
                 tokenizer=tokenizer, 
-                logger=self.logger, 
                 use_cache=(not self.new_mask_store), 
                 parse_output_only=self.parse_output_only,
                 num_samples=self.num_samples, 
@@ -126,7 +123,6 @@ def __init__(
         self.model = HuggingFaceModel(
             model, 
             grammar=self.grammar,
-            logger=self.logger, 
             tokenizer=tokenizer, 
             device=device, 
             grammar_decoder=self.grammar_decoder, 
@@ -137,33 +133,49 @@ def __init__(
     def is_grammar_mode(self):
         return self.mode == 'grammar_mask' or self.mode == 'grammar_strict'
 
-    def infer(self, prompt=None, task_id=None, stop_words=[]):
-        if self.logger.is_closed:
-            self.logger.open()
+    def infer(self, prompt=None, stop_words=[]):
+        output = self.user_input(prompt, stop_words=stop_words)
+        return output
+
+    def evaluate(
+            self, 
+            dataset: Literal["mbxp", "humaneval", "mathqa-x", "gsm8k", "spider", "json_eval"],
+            out_path: str=None,
+            num_few_shot:int=0,
+            logger=common.EmptyLogger(), 
+            task_id=None
+        ) -> dict:
+        """
+        Run evaluation on the model:
+
+        Args:
+            dataset (str): Dataset to evaluate on. Options are "mbxp", "humaneval", "mathqa-x", "gsm8k", "spider", "json_eval".
+        
+            num_few_shot (int, optional): Number of examples for few shot prompting. Defaults to 0.
+
+            task_id (int, optional): For debugging a specific task. Defaults to None.
+        """
+        if logger.is_closed:
+            logger.open()
+
+        # Load the dataset
+        self.dataset = Dataset(dataset, language=self.grammar, num_few_shot=num_few_shot)
 
         if self.dataset.type == "code": 
-            output = CodeEval.run_code_eval(self, self.num_samples, self.out_path, format_tabs=True, debug_task_id=task_id)
+            output = CodeEval.run_code_eval(self, self.num_samples, out_path, format_tabs=True, debug_task_id=task_id, logger=logger)
         elif self.dataset.type == "math":
-            output = MathEval.run_math_eval(self, debug_task_id=task_id)
+            output = MathEval.run_math_eval(self, out_path, debug_task_id=task_id, logger=logger)
         elif self.dataset.type == "sql":
-            output = SQLEval.run_eval(self)
+            output = SQLEval.run_eval(self, out_path)
         elif self.dataset.type == "fol":
-            output = FOLEval.run_eval(self, debug_task_id=task_id)
-        elif self.dataset.type == "input":
-            output = self.user_input(prompt, stop_words=stop_words)
+            output = FOLEval.run_eval(self, out_path, debug_task_id=task_id)
         elif self.dataset.type == "json":
-            output = JSONEval.run_json_eval(self, debug_task_id=task_id)
+            output = JSONEval.run_json_eval(self, out_path, debug_task_id=task_id, logger=logger)
         else:
             raise ValueError(f"Dataset type {self.dataset.type} not supported")
-        self.logger.close()
+        logger.close()
         return output
 
-    def get_output_path(self):
-        out_dir = f"results/{self.model_name}/{self.grammar}/{self.dataset}/"
-        out_path = out_dir + 'samples_' + str(self.num_samples) + '_mode_' + str(self.mode) + "_eval.jsonl"
-        os.makedirs(out_dir, exist_ok=True)
-        return out_dir,out_path
-
     def user_input(self, prompt:str, stop_words=[]):
         """
         Run user input on the model with grammar mask
@@ -175,7 +187,6 @@ def user_input(self, prompt:str, stop_words=[]):
                 return self.model.generate_chat_completion_grammar(prompt)
             else:
                 return self.model.generate_batch_completion_grammar(prompt, self.num_samples, stop_words=stop_words)
-        
         else:
             while True:
                 prompt = input('Enter prompt: ')
diff --git a/syncode/language_model.py b/syncode/language_model.py
index 476ff943..05d80271 100644
--- a/syncode/language_model.py
+++ b/syncode/language_model.py
@@ -35,7 +35,6 @@ def __init__(
             self, 
             model: Callable, 
             grammar: Grammar,
-            logger: common.Logger, 
             tokenizer=None, 
             prompt_template: str = '', 
             best_of: int = 1, 
@@ -48,7 +47,6 @@ def __init__(
 
         self.prompt_template = prompt_template
         self.model = model
-        self.logger = logger
         self.tokenizer = tokenizer
         self.device = device
         self.best_of = best_of
@@ -114,24 +112,19 @@ def generate_batch_completion_grammar(self, prompt, batch_size, stop_words=None)
         # TODO: Move this to CodeEval
         for i in range(batch_size):
             raw_completion = self.tokenizer.decode(generated_ids[i][input_ids_cutoff:len(generated_ids[i])], skip_special_tokens=True)                                       
-            self.logger.log_code("Raw completion", raw_completion)
 
             # Post-processing to filter out using stop word (e.g. "\n\n")
             if self.grammar != None and self.grammar.name == "python":
                 completion = self.postproces_completion_python(i, batch_size, input_ids_cutoff, generated_ids, self.grammar_decoder, raw_completion)
-                self.logger.log_code("Filtered sample", completion)
             elif self.grammar != None and self.grammar.name == "go": 
                 completion = self.postproces_completion_go(i, batch_size, raw_completion, generated_ids, self.grammar_decoder, input_ids_cutoff)
-                self.logger.log_code("Filtered sample", completion)
             else: # TODO: handle the case for other grammars
                 completion = raw_completion
 
             batch_completions.append(completion)
         
-        self.logger.log(f"Completion: {batch_completions}")
         return batch_completions
 
-
     @torch.inference_mode()
     def _generate(
         self, 
@@ -260,7 +253,6 @@ def generate_chat_completion_grammar(self, prompt) -> str:
             generated_ids[0][input_ids_cutoff:len(generated_ids[0])], 
             skip_special_tokens=True)
 
-        self.logger.log_code("Raw completion", completion)
         return completion
 
 
@@ -283,7 +275,6 @@ def postproces_completion_go(self, i, batch_size, raw_completion, generated_ids,
         else:
             # When the grammar_decoder is used
             function_incomplete = [False for _ in range(batch_size)]
-            self.logger.log(f"Function incomplete!")
             completion = self.compute_backup_completion(grammar_decoder, function_incomplete, i, input_ids_cutoff, generated_ids)
 
             if function_incomplete[i]:
@@ -293,9 +284,6 @@ def postproces_completion_go(self, i, batch_size, raw_completion, generated_ids,
         return completion
 
     def compute_backup_completion(self, grammar_decoder, function_incomplete, i, input_ids_cutoff, generated_ids):
-        self.logger.log(f"Last valid state: {grammar_decoder.last_valid_state[i]}")
-        self.logger.log(f"Function end: {grammar_decoder.function_end[i]}")
-
         if grammar_decoder.function_end[i] is not None:
             # if the function end is not None, then the last valid state is the function end
             last_token_id = grammar_decoder.function_end[i]