diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -13,135 +13,6 @@
 peer-to-peer, as it can send and receive all types of JSON-RPC message
 independent of whether it originated the connection.
 
-[Hackage documentation](http://hackage.haskell.org/package/json-rpc)
-
-
-Server Example
---------------
-
-This JSON-RPC server returns the current time.
-
-``` haskell
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE TemplateHaskell #-}
-import Control.Monad
-import Control.Monad.Trans
-import Control.Monad.Logger
-import Data.Aeson.Types hiding (Error)
-import Data.Conduit.Network
-import qualified Data.Foldable as F
-import Data.Maybe
-import Data.Time.Clock
-import Data.Time.Format
-import Network.JsonRpc
-import System.Locale
-
-data TimeReq = TimeReq
-data TimeRes = TimeRes { timeRes :: UTCTime }
-
-instance FromRequest TimeReq where
-    parseParams "time" = Just $ const $ return TimeReq 
-    parseParams _      = Nothing
-
-instance ToJSON TimeRes where
-    toJSON (TimeRes t) = toJSON $ formatTime defaultTimeLocale "%c" t
-
-respond :: MonadLoggerIO m => Respond TimeReq m TimeRes
-respond TimeReq = do
-    t <- liftIO getCurrentTime
-    return . Right $ TimeRes t
-
-main :: IO ()
-main = runStderrLoggingT $ do
-    let ss = serverSettings 31337 "::1"
-    jsonRpcTcpServer V2 False ss srv
-
-srv :: MonadLoggerIO m => JsonRpcT m ()
-srv = do
-    $(logDebug) "listening for new request"
-    qM <- receiveBatchRequest
-    case qM of
-        Nothing -> do
-            $(logDebug) "closed request channel, exting"
-            return ()
-        Just (SingleRequest q) -> do
-            $(logDebug) "got request"
-            rM <- buildResponse respond q
-            F.forM_ rM sendResponse
-            srv
-        Just (BatchRequest qs) -> do
-            $(logDebug) "got request batch"
-            rs <- catMaybes `liftM` forM qs (buildResponse respond)
-            sendBatchResponse $ BatchResponse rs
-            srv
-```
-
-Client Example
---------------
-
-Corresponding TCP client to get time from server.
-
-``` haskell
-{-# LANGUAGE TemplateHaskell #-}
-{-# LANGUAGE OverloadedStrings #-}
-import Control.Concurrent
-import Control.Monad
-import Control.Monad.Trans
-import Control.Monad.Logger
-import Data.Aeson
-import Data.Aeson.Types hiding (Error)
-import Data.Conduit.Network
-import qualified Data.Text as T
-import Data.Time.Clock
-import Data.Time.Format
-import Network.JsonRpc
-import System.Locale
-
-data TimeReq = TimeReq
-data TimeRes = TimeRes { timeRes :: UTCTime } deriving Show
-
-instance ToRequest TimeReq where
-    requestMethod TimeReq = "time"
-    requestIsNotif = const False
-
-instance ToJSON TimeReq where
-    toJSON TimeReq = emptyArray
-
-instance FromResponse TimeRes where
-    parseResult "time" = Just $ withText "time" $ \t -> case f t of
-        Just t' -> return $ TimeRes t'
-        Nothing -> mzero
-      where
-        f t = parseTime defaultTimeLocale "%c" (T.unpack t)
-    parseResult _ = Nothing
-
-req :: MonadLoggerIO m => JsonRpcT m UTCTime
-req = do
-    $(logDebug) "sending time request"
-    ts <- sendRequest TimeReq
-    case ts of
-        Nothing -> error "could not parse response"
-        Just (Left e) -> error $ fromError e
-        Just (Right (TimeRes r)) -> return r
-
-reqBatch :: MonadLoggerIO m => JsonRpcT m [UTCTime]
-reqBatch = do
-    $(logDebug) "sending time requests"
-    ts <- sendBatchRequest $ replicate 4 TimeReq
-    forM ts $ \t ->
-        case t of
-            Nothing -> error "could not parse response"
-            Just (Left e) -> error $ fromError e
-            Just (Right (TimeRes r)) -> return r
-
+[Documentation](http://hackage.haskell.org/package/json-rpc)
 
-main :: IO ()
-main = runStderrLoggingT $
-    jsonRpcTcpClient V2 True (clientSettings 31337 "::1") $ do
-        $(logDebug) "sending four time requests one second apart"
-        replicateM_ 4 $ do
-            req >>= $(logDebug) . T.pack . ("response: "++) . show
-            liftIO (threadDelay 1000000)
-        $(logDebug) "sending four time requests in a batch"
-        reqBatch >>= $(logDebug) . T.pack . ("response: "++) . show
-```
+[Examples](http://github.com/xenog/json-rpc/examples)
diff --git a/json-rpc.cabal b/json-rpc.cabal
--- a/json-rpc.cabal
+++ b/json-rpc.cabal
@@ -1,5 +1,5 @@
 name:                   json-rpc
-version:                0.7.0.0
+version:                0.7.0.1
 synopsis:               Fully-featured JSON-RPC 2.0 library
 description:
   This JSON-RPC library is fully-compatible with JSON-RPC 2.0 and 1.0. It
@@ -24,7 +24,7 @@
 source-repository this
   type:                 git
   location:             https://github.com/xenog/json-rpc.git
-  tag:                  0.7.0.0
+  tag:                  0.7.0.1
 
 library
   exposed-modules:      Network.JsonRpc